diff --git a/CMakeLists.txt b/CMakeLists.txt index 8f19e04..cd6ddac 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -49,6 +49,7 @@ set(CAUDIO_LIB_DIRECTORY "/lib") # Customise what to build option(CAUDIO_STATIC "Static build" FALSE) option(CAUDIO_BUILD_SAMPLES "Build Samples" TRUE) +option(CAUDIO_BUILD_CSHARP_WRAPPER "Build CSharpWrapper - this wrapper is used with the provided *.cs files" FALSE) #Custom settings option(CAUDIO_BUILD_EAX_PLUGIN "Build EAXLegacyPreset Plugin" FALSE) @@ -195,6 +196,10 @@ if(CAUDIO_BUILD_MP3DECODER_PLUGIN) add_subdirectory(Plugins/mp3Decoder) endif() +if(CAUDIO_BUILD_CSHARP_WRAPPER) + add_subdirectory(cAudioCSharpWrapper) +endif() + if(CAUDIO_BUILD_SAMPLES) ADD_DEFINITIONS(-DCAUDIO_MEDIA_ROOT="${CMAKE_SOURCE_DIR}/Samples/Media/") add_subdirectory(Samples/Tutorial1_2DSound) diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer.sln b/Samples/CSharpAudioPlayer/cAudioPlayer.sln new file mode 100644 index 0000000..caa64ae --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "cAudioPlayer", "cAudioPlayer\cAudioPlayer.csproj", "{E7ACE267-B496-440E-B44D-CC846D39DAA7}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "cAudioCSharp", "..\..\cAudioCSharp\cAudioCSharp.csproj", "{4DDC8FD9-BEAF-422E-A28E-093D299F7DEF}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x86 = Debug|x86 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {E7ACE267-B496-440E-B44D-CC846D39DAA7}.Debug|x86.ActiveCfg = Debug|x86 + {E7ACE267-B496-440E-B44D-CC846D39DAA7}.Debug|x86.Build.0 = Debug|x86 + {E7ACE267-B496-440E-B44D-CC846D39DAA7}.Release|x86.ActiveCfg = Release|x86 + {E7ACE267-B496-440E-B44D-CC846D39DAA7}.Release|x86.Build.0 = Release|x86 + {4DDC8FD9-BEAF-422E-A28E-093D299F7DEF}.Debug|x86.ActiveCfg = Debug|x86 + {4DDC8FD9-BEAF-422E-A28E-093D299F7DEF}.Debug|x86.Build.0 = Debug|x86 + {4DDC8FD9-BEAF-422E-A28E-093D299F7DEF}.Release|x86.ActiveCfg = Release|x86 + {4DDC8FD9-BEAF-422E-A28E-093D299F7DEF}.Release|x86.Build.0 = Release|x86 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/AudioSourceListener.cs b/Samples/CSharpAudioPlayer/cAudioPlayer/AudioSourceListener.cs new file mode 100644 index 0000000..3af0292 --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer/AudioSourceListener.cs @@ -0,0 +1,42 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using cAudio; + +namespace cAudioPlayer +{ + public class AudioSourceListener : ISourceEventHandler + { + private readonly MainWnd mPlayer; + public AudioSourceListener(MainWnd player) + { + mPlayer = player; + } + + public override void onUpdate() + { + + } + + public override void onRelease() + { + } + + public override void onPlay() + { + Console.Out.WriteLine("onPlay"); + } + + public override void onStop() + { + Console.Out.WriteLine("onStop"); + mPlayer.OnStop(); + } + + public override void onPause() + { + Console.Out.WriteLine("onPause"); + } + } +} diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/MainWnd.Designer.cs b/Samples/CSharpAudioPlayer/cAudioPlayer/MainWnd.Designer.cs new file mode 100644 index 0000000..cd7694b --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer/MainWnd.Designer.cs @@ -0,0 +1,116 @@ +namespace cAudioPlayer +{ + partial class MainWnd + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.fileNFO = new System.Windows.Forms.Label(); + this.btnOpen = new System.Windows.Forms.Button(); + this.currentPostion = new System.Windows.Forms.TrackBar(); + this.btnPlay = new System.Windows.Forms.Button(); + this.btnStop = new System.Windows.Forms.Button(); + ((System.ComponentModel.ISupportInitialize)(this.currentPostion)).BeginInit(); + this.SuspendLayout(); + // + // fileNFO + // + this.fileNFO.AutoSize = true; + this.fileNFO.Location = new System.Drawing.Point(51, 9); + this.fileNFO.Name = "fileNFO"; + this.fileNFO.Size = new System.Drawing.Size(46, 13); + this.fileNFO.TabIndex = 0; + this.fileNFO.Text = "File: n/a"; + // + // btnOpen + // + this.btnOpen.Location = new System.Drawing.Point(2, 4); + this.btnOpen.Name = "btnOpen"; + this.btnOpen.Size = new System.Drawing.Size(43, 23); + this.btnOpen.TabIndex = 1; + this.btnOpen.Text = "Open"; + this.btnOpen.UseVisualStyleBackColor = true; + this.btnOpen.Click += new System.EventHandler(this.BtnOpenClick); + // + // currentPostion + // + this.currentPostion.Location = new System.Drawing.Point(2, 33); + this.currentPostion.Maximum = 1000; + this.currentPostion.Name = "currentPostion"; + this.currentPostion.Size = new System.Drawing.Size(492, 45); + this.currentPostion.TabIndex = 2; + this.currentPostion.TickStyle = System.Windows.Forms.TickStyle.Both; + // + // btnPlay + // + this.btnPlay.Location = new System.Drawing.Point(2, 84); + this.btnPlay.Name = "btnPlay"; + this.btnPlay.Size = new System.Drawing.Size(43, 23); + this.btnPlay.TabIndex = 3; + this.btnPlay.Text = "Play"; + this.btnPlay.UseVisualStyleBackColor = true; + this.btnPlay.Click += new System.EventHandler(this.BtnPlayClick); + // + // btnStop + // + this.btnStop.Location = new System.Drawing.Point(51, 84); + this.btnStop.Name = "btnStop"; + this.btnStop.Size = new System.Drawing.Size(43, 23); + this.btnStop.TabIndex = 4; + this.btnStop.Text = "Stop"; + this.btnStop.UseVisualStyleBackColor = true; + this.btnStop.Click += new System.EventHandler(this.BtnStopClick); + // + // MainWnd + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(498, 113); + this.Controls.Add(this.btnStop); + this.Controls.Add(this.btnPlay); + this.Controls.Add(this.currentPostion); + this.Controls.Add(this.btnOpen); + this.Controls.Add(this.fileNFO); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Name = "MainWnd"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "cAudio C# Player"; + ((System.ComponentModel.ISupportInitialize)(this.currentPostion)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label fileNFO; + private System.Windows.Forms.Button btnOpen; + private System.Windows.Forms.TrackBar currentPostion; + private System.Windows.Forms.Button btnPlay; + private System.Windows.Forms.Button btnStop; + } +} + diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/MainWnd.cs b/Samples/CSharpAudioPlayer/cAudioPlayer/MainWnd.cs new file mode 100644 index 0000000..4ddc67c --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer/MainWnd.cs @@ -0,0 +1,109 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; +using cAudio; + +namespace cAudioPlayer +{ + public partial class MainWnd : Form + { + private readonly IAudioManager mAudioMgr; + private IAudioSource mCurrentSource; + private readonly AudioSourceListener mAudioListener; + private readonly Timer mUpdateTimer = new Timer(); + public MainWnd() + { + InitializeComponent(); + mAudioMgr = cAudioCSharpWrapper.createAudioManager(true); + mAudioListener = new AudioSourceListener(this); + mUpdateTimer.Tick += UpdateTimerTick; + } + + void UpdateTimerTick(object sender, EventArgs e) + { + UpdateSlider(); + } + + private void BtnOpenClick(object sender, EventArgs e) + { + btnPlay.Text = "Play"; + btnPlay.Enabled = false; + btnStop.Enabled = false; + currentPostion.Value = 0; + mUpdateTimer.Stop(); + + if (mCurrentSource != null) + { + mCurrentSource.unRegisterEventHandler(mAudioListener); + mAudioMgr.release(mCurrentSource); + mCurrentSource = null; + } + + var openFileDlg = new OpenFileDialog(); + if (openFileDlg.ShowDialog() == DialogResult.OK) + { + var file = openFileDlg.FileName; + mCurrentSource = mAudioMgr.create("musicFile", file); + mCurrentSource.registerEventHandler(mAudioListener); + fileNFO.Text = "File:" + file.Substring(file.LastIndexOf("\\") + 1) + " | Length: " + (mCurrentSource.getTotalAudioTime() / 60).ToString("#.00") + " min"; + btnPlay.Enabled = true; + } + + } + + private void BtnPlayClick(object sender, EventArgs e) + { + btnStop.Enabled = true; + if(btnPlay.Text == "Play") + { + btnPlay.Text = "Pause"; + mCurrentSource.play2d(false); + + mUpdateTimer.Interval = 50; + mUpdateTimer.Start(); + } + else + { + btnPlay.Text = "Play"; + mCurrentSource.pause(); + mUpdateTimer.Stop(); + } + } + + private void BtnStopClick(object sender, EventArgs e) + { + OnStop(); + } + + + public void OnStop() + { + btnPlay.Invoke((MethodInvoker)delegate { btnPlay.Text = "Play"; }); + btnStop.Invoke((MethodInvoker)delegate { btnStop.Enabled = false; }); + + if(mCurrentSource.isPlaying()) + mCurrentSource.stop(); + + mUpdateTimer.Stop(); + currentPostion.Invoke((MethodInvoker)delegate { currentPostion.Value = 0; }); + } + + public void UpdateSlider() + { + var percent = (int)((mCurrentSource.getCurrentAudioTime() / mCurrentSource.getTotalAudioTime()) * 1000); + if (currentPostion.InvokeRequired) + { + currentPostion.Invoke((MethodInvoker)delegate { currentPostion.Value = percent; }); + } + else + { + currentPostion.Value = percent; + } + } + } +} diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/MainWnd.resx b/Samples/CSharpAudioPlayer/cAudioPlayer/MainWnd.resx new file mode 100644 index 0000000..29dcb1b --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer/MainWnd.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/Program.cs b/Samples/CSharpAudioPlayer/cAudioPlayer/Program.cs new file mode 100644 index 0000000..5c69189 --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer/Program.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Windows.Forms; + +namespace cAudioPlayer +{ + static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new MainWnd()); + } + } +} diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/AssemblyInfo.cs b/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..15eec88 --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("cAudioPlayer")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("cAudioPlayer")] +[assembly: AssemblyCopyright("Copyright © 2011")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("21f1a254-f4c3-402d-b9d4-ae988fc9086b")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Resources.Designer.cs b/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Resources.Designer.cs new file mode 100644 index 0000000..0e62f5c --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Resources.Designer.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.225 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace cAudioPlayer.Properties +{ + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources + { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() + { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager + { + get + { + if ((resourceMan == null)) + { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("cAudioPlayer.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture + { + get + { + return resourceCulture; + } + set + { + resourceCulture = value; + } + } + } +} diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Resources.resx b/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Resources.resx new file mode 100644 index 0000000..ffecec8 --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Settings.Designer.cs b/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Settings.Designer.cs new file mode 100644 index 0000000..2f59dfd --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.225 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace cAudioPlayer.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Settings.settings b/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Settings.settings new file mode 100644 index 0000000..abf36c5 --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/EAXLegacyPreset_d.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/EAXLegacyPreset_d.dll new file mode 100644 index 0000000..76951dd Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/EAXLegacyPreset_d.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/OpenAL32.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/OpenAL32.dll new file mode 100644 index 0000000..d0ee3cc Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/OpenAL32.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/cAudioCSharp.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/cAudioCSharp.dll new file mode 100644 index 0000000..8362316 Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/cAudioCSharp.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/cAudioCSharpWrapper.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/cAudioCSharpWrapper.dll new file mode 100644 index 0000000..2923c42 Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/cAudioCSharpWrapper.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/cAudio_d.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/cAudio_d.dll new file mode 100644 index 0000000..4257ffa Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/cAudio_d.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/mp3Decoder_d.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/mp3Decoder_d.dll new file mode 100644 index 0000000..cc2a86d Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/mp3Decoder_d.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/wrap_oal.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/wrap_oal.dll new file mode 100644 index 0000000..91e90fc Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Debug/wrap_oal.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/EAXLegacyPreset.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/EAXLegacyPreset.dll new file mode 100644 index 0000000..6e7677e Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/EAXLegacyPreset.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/OpenAL32.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/OpenAL32.dll new file mode 100644 index 0000000..d0ee3cc Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/OpenAL32.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/cAudio.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/cAudio.dll new file mode 100644 index 0000000..924a709 Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/cAudio.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/cAudioCSharp.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/cAudioCSharp.dll new file mode 100644 index 0000000..5023332 Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/cAudioCSharp.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/cAudioCSharpWrapper.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/cAudioCSharpWrapper.dll new file mode 100644 index 0000000..d6fa253 Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/cAudioCSharpWrapper.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/mp3Decoder.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/mp3Decoder.dll new file mode 100644 index 0000000..5527bea Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/mp3Decoder.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/wrap_oal.dll b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/wrap_oal.dll new file mode 100644 index 0000000..91e90fc Binary files /dev/null and b/Samples/CSharpAudioPlayer/cAudioPlayer/bin/Release/wrap_oal.dll differ diff --git a/Samples/CSharpAudioPlayer/cAudioPlayer/cAudioPlayer.csproj b/Samples/CSharpAudioPlayer/cAudioPlayer/cAudioPlayer.csproj new file mode 100644 index 0000000..cbbde15 --- /dev/null +++ b/Samples/CSharpAudioPlayer/cAudioPlayer/cAudioPlayer.csproj @@ -0,0 +1,94 @@ + + + + Debug + x86 + 8.0.30703 + 2.0 + {E7ACE267-B496-440E-B44D-CC846D39DAA7} + WinExe + Properties + cAudioPlayer + cAudioPlayer + v4.0 + Client + 512 + + + x86 + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + x86 + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + Form + + + MainWnd.cs + + + + + MainWnd.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + {4DDC8FD9-BEAF-422E-A28E-093D299F7DEF} + cAudioCSharp + + + + + \ No newline at end of file diff --git a/cAudio/include/ILogger.h b/cAudio/include/ILogger.h index 63c54a5..6bd8dc6 100644 --- a/cAudio/include/ILogger.h +++ b/cAudio/include/ILogger.h @@ -78,11 +78,5 @@ namespace cAudio \return Pointer to the found log receiver or NULL if it could not be found. */ virtual ILogReceiver* getLogReceiver(const char* name) = 0; }; - - //! Gets the interface to the logger. - /** Note: This is the only way to get access to the logging capabilities of cAudio. - \return A pointer to the logger interface. - */ - CAUDIO_API ILogger* getLogger(); }; diff --git a/cAudio/include/cAudio.h b/cAudio/include/cAudio.h index 7d64be3..79b9978 100644 --- a/cAudio/include/cAudio.h +++ b/cAudio/include/cAudio.h @@ -133,4 +133,11 @@ namespace cAudio { \param capture: The object to destroy */ CAUDIO_API void destroyAudioCapture(IAudioCapture* capture); + + + //! Gets the interface to the logger. + /** Note: This is the only way to get access to the logging capabilities of cAudio. + \return A pointer to the logger interface. + */ + CAUDIO_API ILogger* getLogger(); }; diff --git a/cAudio/src/cAudio.cpp b/cAudio/src/cAudio.cpp index f3d4888..a7642c1 100644 --- a/cAudio/src/cAudio.cpp +++ b/cAudio/src/cAudio.cpp @@ -11,9 +11,17 @@ #include "../Headers/cFileSourceFactory.h" #include "../Headers/cFileSource.h" #include "../Headers/cPluginManager.h" +#include "../Headers/cLogger.h" +#include "../Headers/cConsoleLogReceiver.h" +#include "../Headers/cFileLogReceiver.h" namespace cAudio { + + //--------------------------------------------------------------------------------------- + // Audio manager section + //--------------------------------------------------------------------------------------- + #if CAUDIO_COMPILE_WITH_OGG_DECODER == 1 static cOggAudioDecoderFactory OggDecoderFactory; #endif @@ -83,6 +91,10 @@ namespace cAudio } } + //--------------------------------------------------------------------------------------- + // Audio capture section + //--------------------------------------------------------------------------------------- + CAUDIO_API IAudioCapture* createAudioCapture(bool initializeDefault) { cAudioCapture* capture = CAUDIO_NEW cAudioCapture; @@ -117,4 +129,34 @@ namespace cAudio capture = NULL; } } + + //--------------------------------------------------------------------------------------- + // Logger section + //--------------------------------------------------------------------------------------- + + static cLogger Logger; + static bool FirstTimeLogInit(false); + +#if CAUDIO_COMPILE_WITH_CONSOLE_LOG_RECEIVER == 1 + static cConsoleLogReceiver ConsoleLog; +#endif + +#if CAUDIO_COMPILE_WITH_FILE_LOG_RECEIVER == 1 + static cFileLogReceiver FileLog; +#endif + + CAUDIO_API ILogger* getLogger() + { + if(!FirstTimeLogInit) + { + FirstTimeLogInit = true; +#if CAUDIO_COMPILE_WITH_CONSOLE_LOG_RECEIVER == 1 + Logger.registerLogReceiver(&ConsoleLog, "Console"); +#endif +#if CAUDIO_COMPILE_WITH_FILE_LOG_RECEIVER == 1 + Logger.registerLogReceiver(&FileLog,"File"); +#endif + } + return &Logger; + } } diff --git a/cAudio/src/cAudioCapture.cpp b/cAudio/src/cAudioCapture.cpp index 1612be9..256c0bd 100644 --- a/cAudio/src/cAudioCapture.cpp +++ b/cAudio/src/cAudioCapture.cpp @@ -2,6 +2,7 @@ // This file is part of the "cAudio Engine" // For conditions of distribution and use, see copyright notice in cAudio.h +#include "../include/cAudio.h" #include "../Headers/cAudioCapture.h" #include "../Headers/cUtils.h" #include "../Headers/cThread.h" diff --git a/cAudio/src/cAudioManager.cpp b/cAudio/src/cAudioManager.cpp index 56465c1..ffbec3b 100644 --- a/cAudio/src/cAudioManager.cpp +++ b/cAudio/src/cAudioManager.cpp @@ -3,7 +3,7 @@ // For conditions of distribution and use, see copyright notice in cAudio.h #include "../Headers/cAudioManager.h" - +#include "../include/cAudio.h" #include "../include/cAudioPlatform.h" #include "../include/cAudioSleep.h" #include "../Headers/cUtils.h" diff --git a/cAudio/src/cAudioSource.cpp b/cAudio/src/cAudioSource.cpp index 7819024..e5bced7 100644 --- a/cAudio/src/cAudioSource.cpp +++ b/cAudio/src/cAudioSource.cpp @@ -3,6 +3,7 @@ // For conditions of distribution and use, see copyright notice in cAudio.h #include "../Headers/cAudioSource.h" +#include "../include/cAudio.h" #include "../Headers/cLogger.h" #include "../Headers/cFilter.h" #include "../Headers/cEffect.h" diff --git a/cAudio/src/cEffect.cpp b/cAudio/src/cEffect.cpp index bb03fc0..50db5d6 100644 --- a/cAudio/src/cEffect.cpp +++ b/cAudio/src/cEffect.cpp @@ -5,6 +5,7 @@ #include "../Headers/cEffect.h" #include "../Headers/cLogger.h" #include "../Headers/cUtils.h" +#include "../include/cAudio.h" #if CAUDIO_EFX_ENABLED == 1 diff --git a/cAudio/src/cFilter.cpp b/cAudio/src/cFilter.cpp index dc2a70d..783d983 100644 --- a/cAudio/src/cFilter.cpp +++ b/cAudio/src/cFilter.cpp @@ -5,6 +5,7 @@ #include "../Headers/cFilter.h" #include "../Headers/cLogger.h" #include "../Headers/cUtils.h" +#include "../include/cAudio.h" #if CAUDIO_EFX_ENABLED == 1 diff --git a/cAudio/src/cLogger.cpp b/cAudio/src/cLogger.cpp index d22d622..fe9f18b 100644 --- a/cAudio/src/cLogger.cpp +++ b/cAudio/src/cLogger.cpp @@ -11,17 +11,6 @@ namespace cAudio { - static cLogger Logger; - static bool FirstTimeLogInit(false); - -#if CAUDIO_COMPILE_WITH_CONSOLE_LOG_RECEIVER == 1 - static cConsoleLogReceiver ConsoleLog; -#endif - -#if CAUDIO_COMPILE_WITH_FILE_LOG_RECEIVER == 1 - static cFileLogReceiver FileLog; -#endif - cLogger::cLogger() : StartTime(0), MinLogLevel(ELL_INFO) { StartTime = clock(); @@ -148,19 +137,4 @@ namespace cAudio Mutex.unlock(); return NULL; } - - CAUDIO_API ILogger* getLogger() - { - if(!FirstTimeLogInit) - { - FirstTimeLogInit = true; -#if CAUDIO_COMPILE_WITH_CONSOLE_LOG_RECEIVER == 1 - Logger.registerLogReceiver(&ConsoleLog, "Console"); -#endif -#if CAUDIO_COMPILE_WITH_FILE_LOG_RECEIVER == 1 - Logger.registerLogReceiver(&FileLog,"File"); -#endif - } - return &Logger; - } }; diff --git a/cAudio/src/cPluginManager.cpp b/cAudio/src/cPluginManager.cpp index 1bfa1b1..09a7143 100644 --- a/cAudio/src/cPluginManager.cpp +++ b/cAudio/src/cPluginManager.cpp @@ -7,6 +7,7 @@ #include "../include/cAudioPlatform.h" #include "../include/cAudioDefines.h" #include "../include/ILogger.h" +#include "../include/cAudio.h" #ifdef CAUDIO_COMPILE_WITH_PLUGIN_SUPPORT diff --git a/cAudioCSharp/AudioFormats.cs b/cAudioCSharp/AudioFormats.cs new file mode 100644 index 0000000..ba4baf7 --- /dev/null +++ b/cAudioCSharp/AudioFormats.cs @@ -0,0 +1,18 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +public enum AudioFormats { + EAF_8BIT_MONO, + EAF_8BIT_STEREO, + EAF_16BIT_MONO, + EAF_16BIT_STEREO +} + +} diff --git a/cAudioCSharp/DoubleVector.cs b/cAudioCSharp/DoubleVector.cs new file mode 100644 index 0000000..6e77fcd --- /dev/null +++ b/cAudioCSharp/DoubleVector.cs @@ -0,0 +1,349 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class DoubleVector : IDisposable, System.Collections.IEnumerable +#if !SWIG_DOTNET_1 + , System.Collections.Generic.IList +#endif + { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal DoubleVector(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(DoubleVector obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~DoubleVector() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_DoubleVector(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public DoubleVector(System.Collections.ICollection c) : this() { + if (c == null) + throw new ArgumentNullException("c"); + foreach (double element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public double this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + +#if SWIG_DOTNET_1 + public void CopyTo(System.Array array) +#else + public void CopyTo(double[] array) +#endif + { + CopyTo(0, array, 0, this.Count); + } + +#if SWIG_DOTNET_1 + public void CopyTo(System.Array array, int arrayIndex) +#else + public void CopyTo(double[] array, int arrayIndex) +#endif + { + CopyTo(0, array, arrayIndex, this.Count); + } + +#if SWIG_DOTNET_1 + public void CopyTo(int index, System.Array array, int arrayIndex, int count) +#else + public void CopyTo(int index, double[] array, int arrayIndex, int count) +#endif + { + if (array == null) + throw new ArgumentNullException("array"); + if (index < 0) + throw new ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new ArgumentException("Number of elements to copy is too large."); + for (int i=0; i System.Collections.Generic.IEnumerable.GetEnumerator() { + return new DoubleVectorEnumerator(this); + } +#endif + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { + return new DoubleVectorEnumerator(this); + } + + public DoubleVectorEnumerator GetEnumerator() { + return new DoubleVectorEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class DoubleVectorEnumerator : System.Collections.IEnumerator +#if !SWIG_DOTNET_1 + , System.Collections.Generic.IEnumerator +#endif + { + private DoubleVector collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public DoubleVectorEnumerator(DoubleVector collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public double Current { + get { + if (currentIndex == -1) + throw new InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new InvalidOperationException("Collection modified."); + return (double)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new InvalidOperationException("Collection modified."); + } + } + +#if !SWIG_DOTNET_1 + public void Dispose() { + currentIndex = -1; + currentObject = null; + } +#endif + } + + public void Clear() { + cAudioCSharpWrapperPINVOKE.DoubleVector_Clear(swigCPtr); + } + + public void Add(double x) { + cAudioCSharpWrapperPINVOKE.DoubleVector_Add(swigCPtr, x); + } + + private uint size() { + uint ret = cAudioCSharpWrapperPINVOKE.DoubleVector_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = cAudioCSharpWrapperPINVOKE.DoubleVector_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + cAudioCSharpWrapperPINVOKE.DoubleVector_reserve(swigCPtr, n); + } + + public DoubleVector() : this(cAudioCSharpWrapperPINVOKE.new_DoubleVector__SWIG_0(), true) { + } + + public DoubleVector(DoubleVector other) : this(cAudioCSharpWrapperPINVOKE.new_DoubleVector__SWIG_1(DoubleVector.getCPtr(other)), true) { + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public DoubleVector(int capacity) : this(cAudioCSharpWrapperPINVOKE.new_DoubleVector__SWIG_2(capacity), true) { + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + private double getitemcopy(int index) { + double ret = cAudioCSharpWrapperPINVOKE.DoubleVector_getitemcopy(swigCPtr, index); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private double getitem(int index) { + double ret = cAudioCSharpWrapperPINVOKE.DoubleVector_getitem(swigCPtr, index); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, double val) { + cAudioCSharpWrapperPINVOKE.DoubleVector_setitem(swigCPtr, index, val); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(DoubleVector values) { + cAudioCSharpWrapperPINVOKE.DoubleVector_AddRange(swigCPtr, DoubleVector.getCPtr(values)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public DoubleVector GetRange(int index, int count) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.DoubleVector_GetRange(swigCPtr, index, count); + DoubleVector ret = (cPtr == IntPtr.Zero) ? null : new DoubleVector(cPtr, true); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, double x) { + cAudioCSharpWrapperPINVOKE.DoubleVector_Insert(swigCPtr, index, x); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, DoubleVector values) { + cAudioCSharpWrapperPINVOKE.DoubleVector_InsertRange(swigCPtr, index, DoubleVector.getCPtr(values)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + cAudioCSharpWrapperPINVOKE.DoubleVector_RemoveAt(swigCPtr, index); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + cAudioCSharpWrapperPINVOKE.DoubleVector_RemoveRange(swigCPtr, index, count); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public static DoubleVector Repeat(double value, int count) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.DoubleVector_Repeat(value, count); + DoubleVector ret = (cPtr == IntPtr.Zero) ? null : new DoubleVector(cPtr, true); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + cAudioCSharpWrapperPINVOKE.DoubleVector_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + cAudioCSharpWrapperPINVOKE.DoubleVector_Reverse__SWIG_1(swigCPtr, index, count); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, DoubleVector values) { + cAudioCSharpWrapperPINVOKE.DoubleVector_SetRange(swigCPtr, index, DoubleVector.getCPtr(values)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(double value) { + bool ret = cAudioCSharpWrapperPINVOKE.DoubleVector_Contains(swigCPtr, value); + return ret; + } + + public int IndexOf(double value) { + int ret = cAudioCSharpWrapperPINVOKE.DoubleVector_IndexOf(swigCPtr, value); + return ret; + } + + public int LastIndexOf(double value) { + int ret = cAudioCSharpWrapperPINVOKE.DoubleVector_LastIndexOf(swigCPtr, value); + return ret; + } + + public bool Remove(double value) { + bool ret = cAudioCSharpWrapperPINVOKE.DoubleVector_Remove(swigCPtr, value); + return ret; + } + +} + +} diff --git a/cAudioCSharp/IAudioCapture.cs b/cAudioCSharp/IAudioCapture.cs new file mode 100644 index 0000000..bed928d --- /dev/null +++ b/cAudioCSharp/IAudioCapture.cs @@ -0,0 +1,189 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IAudioCapture : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal IAudioCapture(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IAudioCapture obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IAudioCapture() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IAudioCapture(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public virtual bool initialize(string deviceName, uint frequency, AudioFormats format, uint internalBufferSize) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_initialize__SWIG_0(swigCPtr, deviceName, frequency, (int)format, internalBufferSize); + return ret; + } + + public virtual bool initialize(string deviceName, uint frequency, AudioFormats format) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_initialize__SWIG_1(swigCPtr, deviceName, frequency, (int)format); + return ret; + } + + public virtual bool initialize(string deviceName, uint frequency) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_initialize__SWIG_2(swigCPtr, deviceName, frequency); + return ret; + } + + public virtual bool initialize(string deviceName) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_initialize__SWIG_3(swigCPtr, deviceName); + return ret; + } + + public virtual bool initialize() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_initialize__SWIG_4(swigCPtr); + return ret; + } + + public virtual bool isSupported() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_isSupported(swigCPtr); + return ret; + } + + public virtual bool isReady() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_isReady(swigCPtr); + return ret; + } + + public virtual void updateCaptureBuffer(bool force) { + cAudioCSharpWrapperPINVOKE.IAudioCapture_updateCaptureBuffer__SWIG_0(swigCPtr, force); + } + + public virtual void updateCaptureBuffer() { + cAudioCSharpWrapperPINVOKE.IAudioCapture_updateCaptureBuffer__SWIG_1(swigCPtr); + } + + public virtual void shutdown() { + cAudioCSharpWrapperPINVOKE.IAudioCapture_shutdown(swigCPtr); + } + + public virtual bool isUpdateThreadRunning() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_isUpdateThreadRunning(swigCPtr); + return ret; + } + + public virtual string getAvailableDeviceName(uint index) { + string ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_getAvailableDeviceName(swigCPtr, index); + return ret; + } + + public virtual uint getAvailableDeviceCount() { + uint ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_getAvailableDeviceCount(swigCPtr); + return ret; + } + + public virtual string getDefaultDeviceName() { + string ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_getDefaultDeviceName(swigCPtr); + return ret; + } + + public virtual string getDeviceName() { + string ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_getDeviceName(swigCPtr); + return ret; + } + + public virtual uint getFrequency() { + uint ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_getFrequency(swigCPtr); + return ret; + } + + public virtual AudioFormats getFormat() { + AudioFormats ret = (AudioFormats)cAudioCSharpWrapperPINVOKE.IAudioCapture_getFormat(swigCPtr); + return ret; + } + + public virtual uint getInternalBufferSize() { + uint ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_getInternalBufferSize(swigCPtr); + return ret; + } + + public virtual uint getSampleSize() { + uint ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_getSampleSize(swigCPtr); + return ret; + } + + public virtual bool setDevice(string deviceName) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_setDevice(swigCPtr, deviceName); + return ret; + } + + public virtual bool setFrequency(uint frequency) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_setFrequency(swigCPtr, frequency); + return ret; + } + + public virtual bool setFormat(AudioFormats format) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_setFormat(swigCPtr, (int)format); + return ret; + } + + public virtual bool setInternalBufferSize(uint internalBufferSize) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_setInternalBufferSize(swigCPtr, internalBufferSize); + return ret; + } + + public virtual bool beginCapture() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_beginCapture(swigCPtr); + return ret; + } + + public virtual void stopCapture() { + cAudioCSharpWrapperPINVOKE.IAudioCapture_stopCapture(swigCPtr); + } + + public virtual uint getCapturedAudio(SWIGTYPE_p_void outputBuffer, uint outputBufferSize) { + uint ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_getCapturedAudio(swigCPtr, SWIGTYPE_p_void.getCPtr(outputBuffer), outputBufferSize); + return ret; + } + + public virtual uint getCurrentCapturedAudioSize() { + uint ret = cAudioCSharpWrapperPINVOKE.IAudioCapture_getCurrentCapturedAudioSize(swigCPtr); + return ret; + } + + public virtual void registerEventHandler(ICaptureEventHandler handler) { + cAudioCSharpWrapperPINVOKE.IAudioCapture_registerEventHandler(swigCPtr, ICaptureEventHandler.getCPtr(handler)); + } + + public virtual void unRegisterEventHandler(ICaptureEventHandler handler) { + cAudioCSharpWrapperPINVOKE.IAudioCapture_unRegisterEventHandler(swigCPtr, ICaptureEventHandler.getCPtr(handler)); + } + + public virtual void unRegisterAllEventHandlers() { + cAudioCSharpWrapperPINVOKE.IAudioCapture_unRegisterAllEventHandlers(swigCPtr); + } + +} + +} diff --git a/cAudioCSharp/IAudioDecoder.cs b/cAudioCSharp/IAudioDecoder.cs new file mode 100644 index 0000000..6bb17e1 --- /dev/null +++ b/cAudioCSharp/IAudioDecoder.cs @@ -0,0 +1,243 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IAudioDecoder : IRefCounted { + private HandleRef swigCPtr; + + internal IAudioDecoder(IntPtr cPtr, bool cMemoryOwn) : base(cAudioCSharpWrapperPINVOKE.IAudioDecoder_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IAudioDecoder obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IAudioDecoder() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IAudioDecoder(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public IAudioDecoder(IDataSource stream) : this(cAudioCSharpWrapperPINVOKE.new_IAudioDecoder(IDataSource.getCPtr(stream)), true) { + SwigDirectorConnect(); + } + + public virtual AudioFormats getFormat() { + AudioFormats ret = (AudioFormats)cAudioCSharpWrapperPINVOKE.IAudioDecoder_getFormat(swigCPtr); + return ret; + } + + public virtual int getFrequency() { + int ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_getFrequency(swigCPtr); + return ret; + } + + public virtual bool isSeekingSupported() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_isSeekingSupported(swigCPtr); + return ret; + } + + public virtual bool isValid() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_isValid(swigCPtr); + return ret; + } + + public virtual int readAudioData(SWIGTYPE_p_void output, int amount) { + int ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_readAudioData(swigCPtr, SWIGTYPE_p_void.getCPtr(output), amount); + return ret; + } + + public virtual bool setPosition(int position, bool relative) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_setPosition(swigCPtr, position, relative); + return ret; + } + + public virtual bool seek(float seconds, bool relative) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_seek(swigCPtr, seconds, relative); + return ret; + } + + public virtual float getTotalTime() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_getTotalTime(swigCPtr); + return ret; + } + + public virtual int getTotalSize() { + int ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_getTotalSize(swigCPtr); + return ret; + } + + public virtual int getCompressedSize() { + int ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_getCompressedSize(swigCPtr); + return ret; + } + + public virtual float getCurrentTime() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_getCurrentTime(swigCPtr); + return ret; + } + + public virtual int getCurrentPosition() { + int ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_getCurrentPosition(swigCPtr); + return ret; + } + + public virtual int getCurrentCompressedPosition() { + int ret = cAudioCSharpWrapperPINVOKE.IAudioDecoder_getCurrentCompressedPosition(swigCPtr); + return ret; + } + + private void SwigDirectorConnect() { + if (SwigDerivedClassHasMethod("getFormat", swigMethodTypes0)) + swigDelegate0 = new SwigDelegateIAudioDecoder_0(SwigDirectorgetFormat); + if (SwigDerivedClassHasMethod("getFrequency", swigMethodTypes1)) + swigDelegate1 = new SwigDelegateIAudioDecoder_1(SwigDirectorgetFrequency); + if (SwigDerivedClassHasMethod("isSeekingSupported", swigMethodTypes2)) + swigDelegate2 = new SwigDelegateIAudioDecoder_2(SwigDirectorisSeekingSupported); + if (SwigDerivedClassHasMethod("isValid", swigMethodTypes3)) + swigDelegate3 = new SwigDelegateIAudioDecoder_3(SwigDirectorisValid); + if (SwigDerivedClassHasMethod("readAudioData", swigMethodTypes4)) + swigDelegate4 = new SwigDelegateIAudioDecoder_4(SwigDirectorreadAudioData); + if (SwigDerivedClassHasMethod("setPosition", swigMethodTypes5)) + swigDelegate5 = new SwigDelegateIAudioDecoder_5(SwigDirectorsetPosition); + if (SwigDerivedClassHasMethod("seek", swigMethodTypes6)) + swigDelegate6 = new SwigDelegateIAudioDecoder_6(SwigDirectorseek); + if (SwigDerivedClassHasMethod("getTotalTime", swigMethodTypes7)) + swigDelegate7 = new SwigDelegateIAudioDecoder_7(SwigDirectorgetTotalTime); + if (SwigDerivedClassHasMethod("getTotalSize", swigMethodTypes8)) + swigDelegate8 = new SwigDelegateIAudioDecoder_8(SwigDirectorgetTotalSize); + if (SwigDerivedClassHasMethod("getCompressedSize", swigMethodTypes9)) + swigDelegate9 = new SwigDelegateIAudioDecoder_9(SwigDirectorgetCompressedSize); + if (SwigDerivedClassHasMethod("getCurrentTime", swigMethodTypes10)) + swigDelegate10 = new SwigDelegateIAudioDecoder_10(SwigDirectorgetCurrentTime); + if (SwigDerivedClassHasMethod("getCurrentPosition", swigMethodTypes11)) + swigDelegate11 = new SwigDelegateIAudioDecoder_11(SwigDirectorgetCurrentPosition); + if (SwigDerivedClassHasMethod("getCurrentCompressedPosition", swigMethodTypes12)) + swigDelegate12 = new SwigDelegateIAudioDecoder_12(SwigDirectorgetCurrentCompressedPosition); + cAudioCSharpWrapperPINVOKE.IAudioDecoder_director_connect(swigCPtr, swigDelegate0, swigDelegate1, swigDelegate2, swigDelegate3, swigDelegate4, swigDelegate5, swigDelegate6, swigDelegate7, swigDelegate8, swigDelegate9, swigDelegate10, swigDelegate11, swigDelegate12); + } + + private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes) { + System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, methodTypes, null); + bool hasDerivedMethod = methodInfo.DeclaringType.IsSubclassOf(typeof(IAudioDecoder)); + return hasDerivedMethod; + } + + private int SwigDirectorgetFormat() { + return (int)getFormat(); + } + + private int SwigDirectorgetFrequency() { + return getFrequency(); + } + + private bool SwigDirectorisSeekingSupported() { + return isSeekingSupported(); + } + + private bool SwigDirectorisValid() { + return isValid(); + } + + private int SwigDirectorreadAudioData(IntPtr output, int amount) { + return readAudioData((output == IntPtr.Zero) ? null : new SWIGTYPE_p_void(output, false), amount); + } + + private bool SwigDirectorsetPosition(int position, bool relative) { + return setPosition(position, relative); + } + + private bool SwigDirectorseek(float seconds, bool relative) { + return seek(seconds, relative); + } + + private float SwigDirectorgetTotalTime() { + return getTotalTime(); + } + + private int SwigDirectorgetTotalSize() { + return getTotalSize(); + } + + private int SwigDirectorgetCompressedSize() { + return getCompressedSize(); + } + + private float SwigDirectorgetCurrentTime() { + return getCurrentTime(); + } + + private int SwigDirectorgetCurrentPosition() { + return getCurrentPosition(); + } + + private int SwigDirectorgetCurrentCompressedPosition() { + return getCurrentCompressedPosition(); + } + + public delegate int SwigDelegateIAudioDecoder_0(); + public delegate int SwigDelegateIAudioDecoder_1(); + public delegate bool SwigDelegateIAudioDecoder_2(); + public delegate bool SwigDelegateIAudioDecoder_3(); + public delegate int SwigDelegateIAudioDecoder_4(IntPtr output, int amount); + public delegate bool SwigDelegateIAudioDecoder_5(int position, bool relative); + public delegate bool SwigDelegateIAudioDecoder_6(float seconds, bool relative); + public delegate float SwigDelegateIAudioDecoder_7(); + public delegate int SwigDelegateIAudioDecoder_8(); + public delegate int SwigDelegateIAudioDecoder_9(); + public delegate float SwigDelegateIAudioDecoder_10(); + public delegate int SwigDelegateIAudioDecoder_11(); + public delegate int SwigDelegateIAudioDecoder_12(); + + private SwigDelegateIAudioDecoder_0 swigDelegate0; + private SwigDelegateIAudioDecoder_1 swigDelegate1; + private SwigDelegateIAudioDecoder_2 swigDelegate2; + private SwigDelegateIAudioDecoder_3 swigDelegate3; + private SwigDelegateIAudioDecoder_4 swigDelegate4; + private SwigDelegateIAudioDecoder_5 swigDelegate5; + private SwigDelegateIAudioDecoder_6 swigDelegate6; + private SwigDelegateIAudioDecoder_7 swigDelegate7; + private SwigDelegateIAudioDecoder_8 swigDelegate8; + private SwigDelegateIAudioDecoder_9 swigDelegate9; + private SwigDelegateIAudioDecoder_10 swigDelegate10; + private SwigDelegateIAudioDecoder_11 swigDelegate11; + private SwigDelegateIAudioDecoder_12 swigDelegate12; + + private static Type[] swigMethodTypes0 = new Type[] { }; + private static Type[] swigMethodTypes1 = new Type[] { }; + private static Type[] swigMethodTypes2 = new Type[] { }; + private static Type[] swigMethodTypes3 = new Type[] { }; + private static Type[] swigMethodTypes4 = new Type[] { typeof(SWIGTYPE_p_void), typeof(int) }; + private static Type[] swigMethodTypes5 = new Type[] { typeof(int), typeof(bool) }; + private static Type[] swigMethodTypes6 = new Type[] { typeof(float), typeof(bool) }; + private static Type[] swigMethodTypes7 = new Type[] { }; + private static Type[] swigMethodTypes8 = new Type[] { }; + private static Type[] swigMethodTypes9 = new Type[] { }; + private static Type[] swigMethodTypes10 = new Type[] { }; + private static Type[] swigMethodTypes11 = new Type[] { }; + private static Type[] swigMethodTypes12 = new Type[] { }; +} + +} diff --git a/cAudioCSharp/IAudioDecoderFactory.cs b/cAudioCSharp/IAudioDecoderFactory.cs new file mode 100644 index 0000000..1d1b2fe --- /dev/null +++ b/cAudioCSharp/IAudioDecoderFactory.cs @@ -0,0 +1,77 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IAudioDecoderFactory : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal IAudioDecoderFactory(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IAudioDecoderFactory obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IAudioDecoderFactory() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IAudioDecoderFactory(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public IAudioDecoderFactory() : this(cAudioCSharpWrapperPINVOKE.new_IAudioDecoderFactory(), true) { + SwigDirectorConnect(); + } + + public virtual IAudioDecoder CreateAudioDecoder(IDataSource stream) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IAudioDecoderFactory_CreateAudioDecoder(swigCPtr, IDataSource.getCPtr(stream)); + IAudioDecoder ret = (cPtr == IntPtr.Zero) ? null : new IAudioDecoder(cPtr, false); + return ret; + } + + private void SwigDirectorConnect() { + if (SwigDerivedClassHasMethod("CreateAudioDecoder", swigMethodTypes0)) + swigDelegate0 = new SwigDelegateIAudioDecoderFactory_0(SwigDirectorCreateAudioDecoder); + cAudioCSharpWrapperPINVOKE.IAudioDecoderFactory_director_connect(swigCPtr, swigDelegate0); + } + + private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes) { + System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, methodTypes, null); + bool hasDerivedMethod = methodInfo.DeclaringType.IsSubclassOf(typeof(IAudioDecoderFactory)); + return hasDerivedMethod; + } + + private IntPtr SwigDirectorCreateAudioDecoder(IntPtr stream) { + return IAudioDecoder.getCPtr(CreateAudioDecoder((stream == IntPtr.Zero) ? null : new IDataSource(stream, false))).Handle; + } + + public delegate IntPtr SwigDelegateIAudioDecoderFactory_0(IntPtr stream); + + private SwigDelegateIAudioDecoderFactory_0 swigDelegate0; + + private static Type[] swigMethodTypes0 = new Type[] { typeof(IDataSource) }; +} + +} diff --git a/cAudioCSharp/IAudioManager.cs b/cAudioCSharp/IAudioManager.cs new file mode 100644 index 0000000..9b4e8e2 --- /dev/null +++ b/cAudioCSharp/IAudioManager.cs @@ -0,0 +1,199 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IAudioManager : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal IAudioManager(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IAudioManager obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IAudioManager() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IAudioManager(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public virtual bool initialize(string deviceName, int outputFrequency, int eaxEffectSlots) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioManager_initialize__SWIG_0(swigCPtr, deviceName, outputFrequency, eaxEffectSlots); + return ret; + } + + public virtual bool initialize(string deviceName, int outputFrequency) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioManager_initialize__SWIG_1(swigCPtr, deviceName, outputFrequency); + return ret; + } + + public virtual bool initialize(string deviceName) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioManager_initialize__SWIG_2(swigCPtr, deviceName); + return ret; + } + + public virtual bool initialize() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioManager_initialize__SWIG_3(swigCPtr); + return ret; + } + + public virtual void shutDown() { + cAudioCSharpWrapperPINVOKE.IAudioManager_shutDown(swigCPtr); + } + + public virtual void update() { + cAudioCSharpWrapperPINVOKE.IAudioManager_update(swigCPtr); + } + + public virtual bool isUpdateThreadRunning() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioManager_isUpdateThreadRunning(swigCPtr); + return ret; + } + + public virtual IAudioSource getSoundByName(string name) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IAudioManager_getSoundByName(swigCPtr, name); + IAudioSource ret = (cPtr == IntPtr.Zero) ? null : new IAudioSource(cPtr, false); + return ret; + } + + public virtual void releaseAllSources() { + cAudioCSharpWrapperPINVOKE.IAudioManager_releaseAllSources(swigCPtr); + } + + public virtual void release(IAudioSource source) { + cAudioCSharpWrapperPINVOKE.IAudioManager_release(swigCPtr, IAudioSource.getCPtr(source)); + } + + public virtual string getAvailableDeviceName(uint index) { + string ret = cAudioCSharpWrapperPINVOKE.IAudioManager_getAvailableDeviceName(swigCPtr, index); + return ret; + } + + public virtual uint getAvailableDeviceCount() { + uint ret = cAudioCSharpWrapperPINVOKE.IAudioManager_getAvailableDeviceCount(swigCPtr); + return ret; + } + + public virtual string getDefaultDeviceName() { + string ret = cAudioCSharpWrapperPINVOKE.IAudioManager_getDefaultDeviceName(swigCPtr); + return ret; + } + + public virtual IAudioSource create(string name, string filename, bool stream) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IAudioManager_create__SWIG_0(swigCPtr, name, filename, stream); + IAudioSource ret = (cPtr == IntPtr.Zero) ? null : new IAudioSource(cPtr, false); + return ret; + } + + public virtual IAudioSource create(string name, string filename) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IAudioManager_create__SWIG_1(swigCPtr, name, filename); + IAudioSource ret = (cPtr == IntPtr.Zero) ? null : new IAudioSource(cPtr, false); + return ret; + } + + public virtual IAudioSource createFromMemory(string name, string data, uint length, string extension) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IAudioManager_createFromMemory(swigCPtr, name, data, length, extension); + IAudioSource ret = (cPtr == IntPtr.Zero) ? null : new IAudioSource(cPtr, false); + return ret; + } + + public virtual IAudioSource createFromRaw(string name, string data, uint length, uint frequency, SWIGTYPE_p_AudioFormats format) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IAudioManager_createFromRaw(swigCPtr, name, data, length, frequency, SWIGTYPE_p_AudioFormats.getCPtr(format)); + IAudioSource ret = (cPtr == IntPtr.Zero) ? null : new IAudioSource(cPtr, false); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool registerAudioDecoder(IAudioDecoderFactory factory, string extension) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioManager_registerAudioDecoder(swigCPtr, IAudioDecoderFactory.getCPtr(factory), extension); + return ret; + } + + public virtual void unRegisterAudioDecoder(string extension) { + cAudioCSharpWrapperPINVOKE.IAudioManager_unRegisterAudioDecoder(swigCPtr, extension); + } + + public virtual bool isAudioDecoderRegistered(string extension) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioManager_isAudioDecoderRegistered(swigCPtr, extension); + return ret; + } + + public virtual IAudioDecoderFactory getAudioDecoderFactory(string extension) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IAudioManager_getAudioDecoderFactory(swigCPtr, extension); + IAudioDecoderFactory ret = (cPtr == IntPtr.Zero) ? null : new IAudioDecoderFactory(cPtr, false); + return ret; + } + + public virtual void unRegisterAllAudioDecoders() { + cAudioCSharpWrapperPINVOKE.IAudioManager_unRegisterAllAudioDecoders(swigCPtr); + } + + public virtual bool registerDataSource(SWIGTYPE_p_IDataSourceFactory factory, string name, int priority) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioManager_registerDataSource(swigCPtr, SWIGTYPE_p_IDataSourceFactory.getCPtr(factory), name, priority); + return ret; + } + + public virtual void unRegisterDataSource(string name) { + cAudioCSharpWrapperPINVOKE.IAudioManager_unRegisterDataSource(swigCPtr, name); + } + + public virtual bool isDataSourceRegistered(string name) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioManager_isDataSourceRegistered(swigCPtr, name); + return ret; + } + + public virtual SWIGTYPE_p_IDataSourceFactory getDataSourceFactory(string name) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IAudioManager_getDataSourceFactory(swigCPtr, name); + SWIGTYPE_p_IDataSourceFactory ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_IDataSourceFactory(cPtr, false); + return ret; + } + + public virtual void unRegisterAllDataSources() { + cAudioCSharpWrapperPINVOKE.IAudioManager_unRegisterAllDataSources(swigCPtr); + } + + public virtual void registerEventHandler(SWIGTYPE_p_IManagerEventHandler handler) { + cAudioCSharpWrapperPINVOKE.IAudioManager_registerEventHandler(swigCPtr, SWIGTYPE_p_IManagerEventHandler.getCPtr(handler)); + } + + public virtual void unRegisterEventHandler(SWIGTYPE_p_IManagerEventHandler handler) { + cAudioCSharpWrapperPINVOKE.IAudioManager_unRegisterEventHandler(swigCPtr, SWIGTYPE_p_IManagerEventHandler.getCPtr(handler)); + } + + public virtual void unRegisterAllEventHandlers() { + cAudioCSharpWrapperPINVOKE.IAudioManager_unRegisterAllEventHandlers(swigCPtr); + } + + public virtual SWIGTYPE_p_IListener getListener() { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IAudioManager_getListener(swigCPtr); + SWIGTYPE_p_IListener ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_IListener(cPtr, false); + return ret; + } + +} + +} diff --git a/cAudioCSharp/IAudioPlugin.cs b/cAudioCSharp/IAudioPlugin.cs new file mode 100644 index 0000000..1d475cb --- /dev/null +++ b/cAudioCSharp/IAudioPlugin.cs @@ -0,0 +1,75 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IAudioPlugin : IRefCounted { + private HandleRef swigCPtr; + + internal IAudioPlugin(IntPtr cPtr, bool cMemoryOwn) : base(cAudioCSharpWrapperPINVOKE.IAudioPlugin_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IAudioPlugin obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IAudioPlugin() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IAudioPlugin(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public virtual bool installPlugin(SWIGTYPE_p_ILogger logger) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioPlugin_installPlugin(swigCPtr, SWIGTYPE_p_ILogger.getCPtr(logger)); + return ret; + } + + public virtual string getPluginName() { + string ret = cAudioCSharpWrapperPINVOKE.IAudioPlugin_getPluginName(swigCPtr); + return ret; + } + + public virtual void uninstallPlugin() { + cAudioCSharpWrapperPINVOKE.IAudioPlugin_uninstallPlugin(swigCPtr); + } + + public virtual void onCreateAudioManager(IAudioManager manager) { + cAudioCSharpWrapperPINVOKE.IAudioPlugin_onCreateAudioManager(swigCPtr, IAudioManager.getCPtr(manager)); + } + + public virtual void onCreateAudioCapture(SWIGTYPE_p_IAudioCapture capture) { + cAudioCSharpWrapperPINVOKE.IAudioPlugin_onCreateAudioCapture(swigCPtr, SWIGTYPE_p_IAudioCapture.getCPtr(capture)); + } + + public virtual void onDestroyAudioManager(IAudioManager manager) { + cAudioCSharpWrapperPINVOKE.IAudioPlugin_onDestroyAudioManager(swigCPtr, IAudioManager.getCPtr(manager)); + } + + public virtual void onDestoryAudioCapture(SWIGTYPE_p_IAudioCapture capture) { + cAudioCSharpWrapperPINVOKE.IAudioPlugin_onDestoryAudioCapture(swigCPtr, SWIGTYPE_p_IAudioCapture.getCPtr(capture)); + } + +} + +} diff --git a/cAudioCSharp/IAudioSource.cs b/cAudioCSharp/IAudioSource.cs new file mode 100644 index 0000000..9e56416 --- /dev/null +++ b/cAudioCSharp/IAudioSource.cs @@ -0,0 +1,339 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IAudioSource : IRefCounted { + private HandleRef swigCPtr; + + internal IAudioSource(IntPtr cPtr, bool cMemoryOwn) : base(cAudioCSharpWrapperPINVOKE.IAudioSource_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IAudioSource obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IAudioSource() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IAudioSource(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public virtual bool play() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_play(swigCPtr); + return ret; + } + + public virtual bool play2d(bool toLoop) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_play2d__SWIG_0(swigCPtr, toLoop); + return ret; + } + + public virtual bool play2d() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_play2d__SWIG_1(swigCPtr); + return ret; + } + + public virtual bool play3d(SWIGTYPE_p_cVector3 position, float soundstr, bool toLoop) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_play3d__SWIG_0(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(position), soundstr, toLoop); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool play3d(SWIGTYPE_p_cVector3 position, float soundstr) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_play3d__SWIG_1(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(position), soundstr); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool play3d(SWIGTYPE_p_cVector3 position) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_play3d__SWIG_2(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(position)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual void pause() { + cAudioCSharpWrapperPINVOKE.IAudioSource_pause(swigCPtr); + } + + public virtual void stop() { + cAudioCSharpWrapperPINVOKE.IAudioSource_stop(swigCPtr); + } + + public virtual void loop(bool toLoop) { + cAudioCSharpWrapperPINVOKE.IAudioSource_loop(swigCPtr, toLoop); + } + + public virtual bool seek(float seconds, bool relative) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_seek__SWIG_0(swigCPtr, seconds, relative); + return ret; + } + + public virtual bool seek(float seconds) { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_seek__SWIG_1(swigCPtr, seconds); + return ret; + } + + public virtual float getTotalAudioTime() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getTotalAudioTime(swigCPtr); + return ret; + } + + public virtual int getTotalAudioSize() { + int ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getTotalAudioSize(swigCPtr); + return ret; + } + + public virtual int getCompressedAudioSize() { + int ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getCompressedAudioSize(swigCPtr); + return ret; + } + + public virtual float getCurrentAudioTime() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getCurrentAudioTime(swigCPtr); + return ret; + } + + public virtual int getCurrentAudioPosition() { + int ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getCurrentAudioPosition(swigCPtr); + return ret; + } + + public virtual int getCurrentCompressedAudioPosition() { + int ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getCurrentCompressedAudioPosition(swigCPtr); + return ret; + } + + public virtual bool update() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_update(swigCPtr); + return ret; + } + + public virtual void release() { + cAudioCSharpWrapperPINVOKE.IAudioSource_release(swigCPtr); + } + + public virtual bool isValid() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_isValid(swigCPtr); + return ret; + } + + public virtual bool isPlaying() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_isPlaying(swigCPtr); + return ret; + } + + public virtual bool isPaused() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_isPaused(swigCPtr); + return ret; + } + + public virtual bool isStopped() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_isStopped(swigCPtr); + return ret; + } + + public virtual bool isLooping() { + bool ret = cAudioCSharpWrapperPINVOKE.IAudioSource_isLooping(swigCPtr); + return ret; + } + + public virtual void setPosition(SWIGTYPE_p_cVector3 position) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setPosition(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(position)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void setVelocity(SWIGTYPE_p_cVector3 velocity) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setVelocity(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(velocity)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void setDirection(SWIGTYPE_p_cVector3 direction) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setDirection(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(direction)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void setRolloffFactor(float rolloff) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setRolloffFactor(swigCPtr, rolloff); + } + + public virtual void setStrength(float soundstrength) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setStrength(swigCPtr, soundstrength); + } + + public virtual void setMinDistance(float minDistance) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setMinDistance(swigCPtr, minDistance); + } + + public virtual void setMaxDistance(float maxDistance) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setMaxDistance(swigCPtr, maxDistance); + } + + public virtual void setPitch(float pitch) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setPitch(swigCPtr, pitch); + } + + public virtual void setVolume(float volume) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setVolume(swigCPtr, volume); + } + + public virtual void setMinVolume(float minVolume) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setMinVolume(swigCPtr, minVolume); + } + + public virtual void setMaxVolume(float maxVolume) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setMaxVolume(swigCPtr, maxVolume); + } + + public virtual void setInnerConeAngle(float innerAngle) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setInnerConeAngle(swigCPtr, innerAngle); + } + + public virtual void setOuterConeAngle(float outerAngle) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setOuterConeAngle(swigCPtr, outerAngle); + } + + public virtual void setOuterConeVolume(float outerVolume) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setOuterConeVolume(swigCPtr, outerVolume); + } + + public virtual void setDopplerStrength(float dstrength) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setDopplerStrength(swigCPtr, dstrength); + } + + public virtual void setDopplerVelocity(SWIGTYPE_p_cVector3 dvelocity) { + cAudioCSharpWrapperPINVOKE.IAudioSource_setDopplerVelocity(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(dvelocity)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void move(SWIGTYPE_p_cVector3 position) { + cAudioCSharpWrapperPINVOKE.IAudioSource_move(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(position)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual SWIGTYPE_p_cVector3 getPosition() { + SWIGTYPE_p_cVector3 ret = new SWIGTYPE_p_cVector3(cAudioCSharpWrapperPINVOKE.IAudioSource_getPosition(swigCPtr), true); + return ret; + } + + public virtual SWIGTYPE_p_cVector3 getVelocity() { + SWIGTYPE_p_cVector3 ret = new SWIGTYPE_p_cVector3(cAudioCSharpWrapperPINVOKE.IAudioSource_getVelocity(swigCPtr), true); + return ret; + } + + public virtual SWIGTYPE_p_cVector3 getDirection() { + SWIGTYPE_p_cVector3 ret = new SWIGTYPE_p_cVector3(cAudioCSharpWrapperPINVOKE.IAudioSource_getDirection(swigCPtr), true); + return ret; + } + + public virtual float getRolloffFactor() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getRolloffFactor(swigCPtr); + return ret; + } + + public virtual float getStrength() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getStrength(swigCPtr); + return ret; + } + + public virtual float getMinDistance() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getMinDistance(swigCPtr); + return ret; + } + + public virtual float getMaxDistance() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getMaxDistance(swigCPtr); + return ret; + } + + public virtual float getPitch() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getPitch(swigCPtr); + return ret; + } + + public virtual float getVolume() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getVolume(swigCPtr); + return ret; + } + + public virtual float getMinVolume() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getMinVolume(swigCPtr); + return ret; + } + + public virtual float getMaxVolume() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getMaxVolume(swigCPtr); + return ret; + } + + public virtual float getInnerConeAngle() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getInnerConeAngle(swigCPtr); + return ret; + } + + public virtual float getOuterConeAngle() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getOuterConeAngle(swigCPtr); + return ret; + } + + public virtual float getOuterConeVolume() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getOuterConeVolume(swigCPtr); + return ret; + } + + public virtual float getDopplerStrength() { + float ret = cAudioCSharpWrapperPINVOKE.IAudioSource_getDopplerStrength(swigCPtr); + return ret; + } + + public virtual SWIGTYPE_p_cVector3 getDopplerVelocity() { + SWIGTYPE_p_cVector3 ret = new SWIGTYPE_p_cVector3(cAudioCSharpWrapperPINVOKE.IAudioSource_getDopplerVelocity(swigCPtr), true); + return ret; + } + + public virtual void registerEventHandler(ISourceEventHandler handler) + { + cAudioCSharpWrapperPINVOKE.IAudioSource_registerEventHandler(swigCPtr, ISourceEventHandler.getCPtr(handler)); + } + + public virtual void unRegisterEventHandler(ISourceEventHandler handler) + { + cAudioCSharpWrapperPINVOKE.IAudioSource_unRegisterEventHandler(swigCPtr, ISourceEventHandler.getCPtr(handler)); + } + + public virtual void registerEventHandler(SWIGTYPE_p_ISourceEventHandler handler) { + cAudioCSharpWrapperPINVOKE.IAudioSource_registerEventHandler(swigCPtr, SWIGTYPE_p_ISourceEventHandler.getCPtr(handler)); + } + + public virtual void unRegisterEventHandler(SWIGTYPE_p_ISourceEventHandler handler) { + cAudioCSharpWrapperPINVOKE.IAudioSource_unRegisterEventHandler(swigCPtr, SWIGTYPE_p_ISourceEventHandler.getCPtr(handler)); + } + + public virtual void unRegisterAllEventHandlers() { + cAudioCSharpWrapperPINVOKE.IAudioSource_unRegisterAllEventHandlers(swigCPtr); + } + +} + +} diff --git a/cAudioCSharp/ICaptureEventHandler.cs b/cAudioCSharp/ICaptureEventHandler.cs new file mode 100644 index 0000000..3a465de --- /dev/null +++ b/cAudioCSharp/ICaptureEventHandler.cs @@ -0,0 +1,140 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class ICaptureEventHandler : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal ICaptureEventHandler(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(ICaptureEventHandler obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~ICaptureEventHandler() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_ICaptureEventHandler(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public virtual void onInit() { + cAudioCSharpWrapperPINVOKE.ICaptureEventHandler_onInit(swigCPtr); + } + + public virtual void onUpdate() { + cAudioCSharpWrapperPINVOKE.ICaptureEventHandler_onUpdate(swigCPtr); + } + + public virtual void onRelease() { + cAudioCSharpWrapperPINVOKE.ICaptureEventHandler_onRelease(swigCPtr); + } + + public virtual void onBeginCapture() { + cAudioCSharpWrapperPINVOKE.ICaptureEventHandler_onBeginCapture(swigCPtr); + } + + public virtual void onEndCapture() { + cAudioCSharpWrapperPINVOKE.ICaptureEventHandler_onEndCapture(swigCPtr); + } + + public virtual void onUserRequestBuffer() { + cAudioCSharpWrapperPINVOKE.ICaptureEventHandler_onUserRequestBuffer(swigCPtr); + } + + public ICaptureEventHandler() : this(cAudioCSharpWrapperPINVOKE.new_ICaptureEventHandler(), true) { + SwigDirectorConnect(); + } + + private void SwigDirectorConnect() { + if (SwigDerivedClassHasMethod("onInit", swigMethodTypes0)) + swigDelegate0 = new SwigDelegateICaptureEventHandler_0(SwigDirectoronInit); + if (SwigDerivedClassHasMethod("onUpdate", swigMethodTypes1)) + swigDelegate1 = new SwigDelegateICaptureEventHandler_1(SwigDirectoronUpdate); + if (SwigDerivedClassHasMethod("onRelease", swigMethodTypes2)) + swigDelegate2 = new SwigDelegateICaptureEventHandler_2(SwigDirectoronRelease); + if (SwigDerivedClassHasMethod("onBeginCapture", swigMethodTypes3)) + swigDelegate3 = new SwigDelegateICaptureEventHandler_3(SwigDirectoronBeginCapture); + if (SwigDerivedClassHasMethod("onEndCapture", swigMethodTypes4)) + swigDelegate4 = new SwigDelegateICaptureEventHandler_4(SwigDirectoronEndCapture); + if (SwigDerivedClassHasMethod("onUserRequestBuffer", swigMethodTypes5)) + swigDelegate5 = new SwigDelegateICaptureEventHandler_5(SwigDirectoronUserRequestBuffer); + cAudioCSharpWrapperPINVOKE.ICaptureEventHandler_director_connect(swigCPtr, swigDelegate0, swigDelegate1, swigDelegate2, swigDelegate3, swigDelegate4, swigDelegate5); + } + + private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes) { + System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, methodTypes, null); + bool hasDerivedMethod = methodInfo.DeclaringType.IsSubclassOf(typeof(ICaptureEventHandler)); + return hasDerivedMethod; + } + + private void SwigDirectoronInit() { + onInit(); + } + + private void SwigDirectoronUpdate() { + onUpdate(); + } + + private void SwigDirectoronRelease() { + onRelease(); + } + + private void SwigDirectoronBeginCapture() { + onBeginCapture(); + } + + private void SwigDirectoronEndCapture() { + onEndCapture(); + } + + private void SwigDirectoronUserRequestBuffer() { + onUserRequestBuffer(); + } + + public delegate void SwigDelegateICaptureEventHandler_0(); + public delegate void SwigDelegateICaptureEventHandler_1(); + public delegate void SwigDelegateICaptureEventHandler_2(); + public delegate void SwigDelegateICaptureEventHandler_3(); + public delegate void SwigDelegateICaptureEventHandler_4(); + public delegate void SwigDelegateICaptureEventHandler_5(); + + private SwigDelegateICaptureEventHandler_0 swigDelegate0; + private SwigDelegateICaptureEventHandler_1 swigDelegate1; + private SwigDelegateICaptureEventHandler_2 swigDelegate2; + private SwigDelegateICaptureEventHandler_3 swigDelegate3; + private SwigDelegateICaptureEventHandler_4 swigDelegate4; + private SwigDelegateICaptureEventHandler_5 swigDelegate5; + + private static Type[] swigMethodTypes0 = new Type[] { }; + private static Type[] swigMethodTypes1 = new Type[] { }; + private static Type[] swigMethodTypes2 = new Type[] { }; + private static Type[] swigMethodTypes3 = new Type[] { }; + private static Type[] swigMethodTypes4 = new Type[] { }; + private static Type[] swigMethodTypes5 = new Type[] { }; +} + +} diff --git a/cAudioCSharp/IDataSource.cs b/cAudioCSharp/IDataSource.cs new file mode 100644 index 0000000..b2fb011 --- /dev/null +++ b/cAudioCSharp/IDataSource.cs @@ -0,0 +1,131 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IDataSource : IRefCounted { + private HandleRef swigCPtr; + + internal IDataSource(IntPtr cPtr, bool cMemoryOwn) : base(cAudioCSharpWrapperPINVOKE.IDataSource_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IDataSource obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IDataSource() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IDataSource(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public IDataSource() : this(cAudioCSharpWrapperPINVOKE.new_IDataSource(), true) { + SwigDirectorConnect(); + } + + public virtual bool isValid() { + bool ret = cAudioCSharpWrapperPINVOKE.IDataSource_isValid(swigCPtr); + return ret; + } + + public virtual int getCurrentPos() { + int ret = cAudioCSharpWrapperPINVOKE.IDataSource_getCurrentPos(swigCPtr); + return ret; + } + + public virtual int getSize() { + int ret = cAudioCSharpWrapperPINVOKE.IDataSource_getSize(swigCPtr); + return ret; + } + + public virtual int read(SWIGTYPE_p_void output, int size) { + int ret = cAudioCSharpWrapperPINVOKE.IDataSource_read(swigCPtr, SWIGTYPE_p_void.getCPtr(output), size); + return ret; + } + + public virtual bool seek(int amount, bool relative) { + bool ret = cAudioCSharpWrapperPINVOKE.IDataSource_seek(swigCPtr, amount, relative); + return ret; + } + + private void SwigDirectorConnect() { + if (SwigDerivedClassHasMethod("isValid", swigMethodTypes0)) + swigDelegate0 = new SwigDelegateIDataSource_0(SwigDirectorisValid); + if (SwigDerivedClassHasMethod("getCurrentPos", swigMethodTypes1)) + swigDelegate1 = new SwigDelegateIDataSource_1(SwigDirectorgetCurrentPos); + if (SwigDerivedClassHasMethod("getSize", swigMethodTypes2)) + swigDelegate2 = new SwigDelegateIDataSource_2(SwigDirectorgetSize); + if (SwigDerivedClassHasMethod("read", swigMethodTypes3)) + swigDelegate3 = new SwigDelegateIDataSource_3(SwigDirectorread); + if (SwigDerivedClassHasMethod("seek", swigMethodTypes4)) + swigDelegate4 = new SwigDelegateIDataSource_4(SwigDirectorseek); + cAudioCSharpWrapperPINVOKE.IDataSource_director_connect(swigCPtr, swigDelegate0, swigDelegate1, swigDelegate2, swigDelegate3, swigDelegate4); + } + + private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes) { + System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, methodTypes, null); + bool hasDerivedMethod = methodInfo.DeclaringType.IsSubclassOf(typeof(IDataSource)); + return hasDerivedMethod; + } + + private bool SwigDirectorisValid() { + return isValid(); + } + + private int SwigDirectorgetCurrentPos() { + return getCurrentPos(); + } + + private int SwigDirectorgetSize() { + return getSize(); + } + + private int SwigDirectorread(IntPtr output, int size) { + return read((output == IntPtr.Zero) ? null : new SWIGTYPE_p_void(output, false), size); + } + + private bool SwigDirectorseek(int amount, bool relative) { + return seek(amount, relative); + } + + public delegate bool SwigDelegateIDataSource_0(); + public delegate int SwigDelegateIDataSource_1(); + public delegate int SwigDelegateIDataSource_2(); + public delegate int SwigDelegateIDataSource_3(IntPtr output, int size); + public delegate bool SwigDelegateIDataSource_4(int amount, bool relative); + + private SwigDelegateIDataSource_0 swigDelegate0; + private SwigDelegateIDataSource_1 swigDelegate1; + private SwigDelegateIDataSource_2 swigDelegate2; + private SwigDelegateIDataSource_3 swigDelegate3; + private SwigDelegateIDataSource_4 swigDelegate4; + + private static Type[] swigMethodTypes0 = new Type[] { }; + private static Type[] swigMethodTypes1 = new Type[] { }; + private static Type[] swigMethodTypes2 = new Type[] { }; + private static Type[] swigMethodTypes3 = new Type[] { typeof(SWIGTYPE_p_void), typeof(int) }; + private static Type[] swigMethodTypes4 = new Type[] { typeof(int), typeof(bool) }; +} + +} diff --git a/cAudioCSharp/IDataSourceFactory.cs b/cAudioCSharp/IDataSourceFactory.cs new file mode 100644 index 0000000..a5f680c --- /dev/null +++ b/cAudioCSharp/IDataSourceFactory.cs @@ -0,0 +1,77 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IDataSourceFactory : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal IDataSourceFactory(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IDataSourceFactory obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IDataSourceFactory() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IDataSourceFactory(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public IDataSourceFactory() : this(cAudioCSharpWrapperPINVOKE.new_IDataSourceFactory(), true) { + SwigDirectorConnect(); + } + + public virtual IDataSource CreateDataSource(string filename, bool streamingRequested) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IDataSourceFactory_CreateDataSource(swigCPtr, filename, streamingRequested); + IDataSource ret = (cPtr == IntPtr.Zero) ? null : new IDataSource(cPtr, false); + return ret; + } + + private void SwigDirectorConnect() { + if (SwigDerivedClassHasMethod("CreateDataSource", swigMethodTypes0)) + swigDelegate0 = new SwigDelegateIDataSourceFactory_0(SwigDirectorCreateDataSource); + cAudioCSharpWrapperPINVOKE.IDataSourceFactory_director_connect(swigCPtr, swigDelegate0); + } + + private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes) { + System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, methodTypes, null); + bool hasDerivedMethod = methodInfo.DeclaringType.IsSubclassOf(typeof(IDataSourceFactory)); + return hasDerivedMethod; + } + + private IntPtr SwigDirectorCreateDataSource(string filename, bool streamingRequested) { + return IDataSource.getCPtr(CreateDataSource(filename, streamingRequested)).Handle; + } + + public delegate IntPtr SwigDelegateIDataSourceFactory_0(string filename, bool streamingRequested); + + private SwigDelegateIDataSourceFactory_0 swigDelegate0; + + private static Type[] swigMethodTypes0 = new Type[] { typeof(string), typeof(bool) }; +} + +} diff --git a/cAudioCSharp/IListener.cs b/cAudioCSharp/IListener.cs new file mode 100644 index 0000000..b2d089a --- /dev/null +++ b/cAudioCSharp/IListener.cs @@ -0,0 +1,100 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IListener : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal IListener(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IListener obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IListener() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IListener(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public virtual void setPosition(SWIGTYPE_p_cVector3 pos) { + cAudioCSharpWrapperPINVOKE.IListener_setPosition(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(pos)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void setDirection(SWIGTYPE_p_cVector3 dir) { + cAudioCSharpWrapperPINVOKE.IListener_setDirection(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(dir)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void setUpVector(SWIGTYPE_p_cVector3 up) { + cAudioCSharpWrapperPINVOKE.IListener_setUpVector(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(up)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void setVelocity(SWIGTYPE_p_cVector3 vel) { + cAudioCSharpWrapperPINVOKE.IListener_setVelocity(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(vel)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void setMasterVolume(float volume) { + cAudioCSharpWrapperPINVOKE.IListener_setMasterVolume(swigCPtr, volume); + } + + public virtual void move(SWIGTYPE_p_cVector3 pos) { + cAudioCSharpWrapperPINVOKE.IListener_move(swigCPtr, SWIGTYPE_p_cVector3.getCPtr(pos)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual SWIGTYPE_p_cVector3 getPosition() { + SWIGTYPE_p_cVector3 ret = new SWIGTYPE_p_cVector3(cAudioCSharpWrapperPINVOKE.IListener_getPosition(swigCPtr), true); + return ret; + } + + public virtual SWIGTYPE_p_cVector3 getDirection() { + SWIGTYPE_p_cVector3 ret = new SWIGTYPE_p_cVector3(cAudioCSharpWrapperPINVOKE.IListener_getDirection(swigCPtr), true); + return ret; + } + + public virtual SWIGTYPE_p_cVector3 getUpVector() { + SWIGTYPE_p_cVector3 ret = new SWIGTYPE_p_cVector3(cAudioCSharpWrapperPINVOKE.IListener_getUpVector(swigCPtr), true); + return ret; + } + + public virtual SWIGTYPE_p_cVector3 getVelocity() { + SWIGTYPE_p_cVector3 ret = new SWIGTYPE_p_cVector3(cAudioCSharpWrapperPINVOKE.IListener_getVelocity(swigCPtr), true); + return ret; + } + + public virtual float getMasterVolume() { + float ret = cAudioCSharpWrapperPINVOKE.IListener_getMasterVolume(swigCPtr); + return ret; + } + +} + +} diff --git a/cAudioCSharp/ILogReceiver.cs b/cAudioCSharp/ILogReceiver.cs new file mode 100644 index 0000000..acc0f91 --- /dev/null +++ b/cAudioCSharp/ILogReceiver.cs @@ -0,0 +1,76 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class ILogReceiver : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal ILogReceiver(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(ILogReceiver obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~ILogReceiver() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_ILogReceiver(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public ILogReceiver() : this(cAudioCSharpWrapperPINVOKE.new_ILogReceiver(), true) { + SwigDirectorConnect(); + } + + public virtual bool OnLogMessage(string sender, string message, LogLevel level, float time) { + bool ret = cAudioCSharpWrapperPINVOKE.ILogReceiver_OnLogMessage(swigCPtr, sender, message, (int)level, time); + return ret; + } + + private void SwigDirectorConnect() { + if (SwigDerivedClassHasMethod("OnLogMessage", swigMethodTypes0)) + swigDelegate0 = new SwigDelegateILogReceiver_0(SwigDirectorOnLogMessage); + cAudioCSharpWrapperPINVOKE.ILogReceiver_director_connect(swigCPtr, swigDelegate0); + } + + private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes) { + System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, methodTypes, null); + bool hasDerivedMethod = methodInfo.DeclaringType.IsSubclassOf(typeof(ILogReceiver)); + return hasDerivedMethod; + } + + private bool SwigDirectorOnLogMessage(string sender, string message, int level, float time) { + return OnLogMessage(sender, message, (LogLevel)level, time); + } + + public delegate bool SwigDelegateILogReceiver_0(string sender, string message, int level, float time); + + private SwigDelegateILogReceiver_0 swigDelegate0; + + private static Type[] swigMethodTypes0 = new Type[] { typeof(string), typeof(string), typeof(LogLevel), typeof(float) }; +} + +} diff --git a/cAudioCSharp/ILogger.cs b/cAudioCSharp/ILogger.cs new file mode 100644 index 0000000..70cbddf --- /dev/null +++ b/cAudioCSharp/ILogger.cs @@ -0,0 +1,96 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class ILogger : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal ILogger(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(ILogger obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~ILogger() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_ILogger(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public virtual void logCritical(string sender, string msg) { + cAudioCSharpWrapperPINVOKE.ILogger_logCritical(swigCPtr, sender, msg); + } + + public virtual void logError(string sender, string msg) { + cAudioCSharpWrapperPINVOKE.ILogger_logError(swigCPtr, sender, msg); + } + + public virtual void logWarning(string sender, string msg) { + cAudioCSharpWrapperPINVOKE.ILogger_logWarning(swigCPtr, sender, msg); + } + + public virtual void logInfo(string sender, string msg) { + cAudioCSharpWrapperPINVOKE.ILogger_logInfo(swigCPtr, sender, msg); + } + + public virtual void logDebug(string sender, string msg) { + cAudioCSharpWrapperPINVOKE.ILogger_logDebug(swigCPtr, sender, msg); + } + + public virtual SWIGTYPE_p_LogLevel getLogLevel() { + SWIGTYPE_p_LogLevel ret = new SWIGTYPE_p_LogLevel(cAudioCSharpWrapperPINVOKE.ILogger_getLogLevel(swigCPtr), false); + return ret; + } + + public virtual void setLogLevel(SWIGTYPE_p_LogLevel logLevel) { + cAudioCSharpWrapperPINVOKE.ILogger_setLogLevel(swigCPtr, SWIGTYPE_p_LogLevel.getCPtr(logLevel)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual bool registerLogReceiver(SWIGTYPE_p_ILogReceiver receiver, string name) { + bool ret = cAudioCSharpWrapperPINVOKE.ILogger_registerLogReceiver(swigCPtr, SWIGTYPE_p_ILogReceiver.getCPtr(receiver), name); + return ret; + } + + public virtual void unRegisterLogReceiver(string name) { + cAudioCSharpWrapperPINVOKE.ILogger_unRegisterLogReceiver(swigCPtr, name); + } + + public virtual bool isLogReceiverRegistered(string name) { + bool ret = cAudioCSharpWrapperPINVOKE.ILogger_isLogReceiverRegistered(swigCPtr, name); + return ret; + } + + public virtual SWIGTYPE_p_ILogReceiver getLogReceiver(string name) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.ILogger_getLogReceiver(swigCPtr, name); + SWIGTYPE_p_ILogReceiver ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_ILogReceiver(cPtr, false); + return ret; + } + +} + +} diff --git a/cAudioCSharp/IManagerEventHandler.cs b/cAudioCSharp/IManagerEventHandler.cs new file mode 100644 index 0000000..6b34635 --- /dev/null +++ b/cAudioCSharp/IManagerEventHandler.cs @@ -0,0 +1,140 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IManagerEventHandler : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal IManagerEventHandler(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IManagerEventHandler obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IManagerEventHandler() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IManagerEventHandler(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public virtual void onInit() { + cAudioCSharpWrapperPINVOKE.IManagerEventHandler_onInit(swigCPtr); + } + + public virtual void onUpdate() { + cAudioCSharpWrapperPINVOKE.IManagerEventHandler_onUpdate(swigCPtr); + } + + public virtual void onRelease() { + cAudioCSharpWrapperPINVOKE.IManagerEventHandler_onRelease(swigCPtr); + } + + public virtual void onSourceCreate() { + cAudioCSharpWrapperPINVOKE.IManagerEventHandler_onSourceCreate(swigCPtr); + } + + public virtual void onDecoderRegister() { + cAudioCSharpWrapperPINVOKE.IManagerEventHandler_onDecoderRegister(swigCPtr); + } + + public virtual void onDataSourceRegister() { + cAudioCSharpWrapperPINVOKE.IManagerEventHandler_onDataSourceRegister(swigCPtr); + } + + public IManagerEventHandler() : this(cAudioCSharpWrapperPINVOKE.new_IManagerEventHandler(), true) { + SwigDirectorConnect(); + } + + private void SwigDirectorConnect() { + if (SwigDerivedClassHasMethod("onInit", swigMethodTypes0)) + swigDelegate0 = new SwigDelegateIManagerEventHandler_0(SwigDirectoronInit); + if (SwigDerivedClassHasMethod("onUpdate", swigMethodTypes1)) + swigDelegate1 = new SwigDelegateIManagerEventHandler_1(SwigDirectoronUpdate); + if (SwigDerivedClassHasMethod("onRelease", swigMethodTypes2)) + swigDelegate2 = new SwigDelegateIManagerEventHandler_2(SwigDirectoronRelease); + if (SwigDerivedClassHasMethod("onSourceCreate", swigMethodTypes3)) + swigDelegate3 = new SwigDelegateIManagerEventHandler_3(SwigDirectoronSourceCreate); + if (SwigDerivedClassHasMethod("onDecoderRegister", swigMethodTypes4)) + swigDelegate4 = new SwigDelegateIManagerEventHandler_4(SwigDirectoronDecoderRegister); + if (SwigDerivedClassHasMethod("onDataSourceRegister", swigMethodTypes5)) + swigDelegate5 = new SwigDelegateIManagerEventHandler_5(SwigDirectoronDataSourceRegister); + cAudioCSharpWrapperPINVOKE.IManagerEventHandler_director_connect(swigCPtr, swigDelegate0, swigDelegate1, swigDelegate2, swigDelegate3, swigDelegate4, swigDelegate5); + } + + private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes) { + System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, methodTypes, null); + bool hasDerivedMethod = methodInfo.DeclaringType.IsSubclassOf(typeof(IManagerEventHandler)); + return hasDerivedMethod; + } + + private void SwigDirectoronInit() { + onInit(); + } + + private void SwigDirectoronUpdate() { + onUpdate(); + } + + private void SwigDirectoronRelease() { + onRelease(); + } + + private void SwigDirectoronSourceCreate() { + onSourceCreate(); + } + + private void SwigDirectoronDecoderRegister() { + onDecoderRegister(); + } + + private void SwigDirectoronDataSourceRegister() { + onDataSourceRegister(); + } + + public delegate void SwigDelegateIManagerEventHandler_0(); + public delegate void SwigDelegateIManagerEventHandler_1(); + public delegate void SwigDelegateIManagerEventHandler_2(); + public delegate void SwigDelegateIManagerEventHandler_3(); + public delegate void SwigDelegateIManagerEventHandler_4(); + public delegate void SwigDelegateIManagerEventHandler_5(); + + private SwigDelegateIManagerEventHandler_0 swigDelegate0; + private SwigDelegateIManagerEventHandler_1 swigDelegate1; + private SwigDelegateIManagerEventHandler_2 swigDelegate2; + private SwigDelegateIManagerEventHandler_3 swigDelegate3; + private SwigDelegateIManagerEventHandler_4 swigDelegate4; + private SwigDelegateIManagerEventHandler_5 swigDelegate5; + + private static Type[] swigMethodTypes0 = new Type[] { }; + private static Type[] swigMethodTypes1 = new Type[] { }; + private static Type[] swigMethodTypes2 = new Type[] { }; + private static Type[] swigMethodTypes3 = new Type[] { }; + private static Type[] swigMethodTypes4 = new Type[] { }; + private static Type[] swigMethodTypes5 = new Type[] { }; +} + +} diff --git a/cAudioCSharp/IMemoryProvider.cs b/cAudioCSharp/IMemoryProvider.cs new file mode 100644 index 0000000..879c477 --- /dev/null +++ b/cAudioCSharp/IMemoryProvider.cs @@ -0,0 +1,61 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IMemoryProvider : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal IMemoryProvider(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IMemoryProvider obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IMemoryProvider() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IMemoryProvider(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public virtual SWIGTYPE_p_void Allocate(uint size, string filename, int line, string function) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IMemoryProvider_Allocate(swigCPtr, size, filename, line, function); + SWIGTYPE_p_void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_void(cPtr, false); + return ret; + } + + public virtual void Free(SWIGTYPE_p_void pointer) { + cAudioCSharpWrapperPINVOKE.IMemoryProvider_Free(swigCPtr, SWIGTYPE_p_void.getCPtr(pointer)); + } + + public virtual uint getMaxAllocationSize() { + uint ret = cAudioCSharpWrapperPINVOKE.IMemoryProvider_getMaxAllocationSize(swigCPtr); + return ret; + } + +} + +} diff --git a/cAudioCSharp/IRefCounted.cs b/cAudioCSharp/IRefCounted.cs new file mode 100644 index 0000000..da0b4e9 --- /dev/null +++ b/cAudioCSharp/IRefCounted.cs @@ -0,0 +1,63 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IRefCounted : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal IRefCounted(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IRefCounted obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IRefCounted() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IRefCounted(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public IRefCounted() : this(cAudioCSharpWrapperPINVOKE.new_IRefCounted(), true) { + } + + public void grab() { + cAudioCSharpWrapperPINVOKE.IRefCounted_grab(swigCPtr); + } + + public bool drop() { + bool ret = cAudioCSharpWrapperPINVOKE.IRefCounted_drop(swigCPtr); + return ret; + } + + public int getReferenceCount() { + int ret = cAudioCSharpWrapperPINVOKE.IRefCounted_getReferenceCount(swigCPtr); + return ret; + } + +} + +} diff --git a/cAudioCSharp/ISourceEventHandler.cs b/cAudioCSharp/ISourceEventHandler.cs new file mode 100644 index 0000000..4950535 --- /dev/null +++ b/cAudioCSharp/ISourceEventHandler.cs @@ -0,0 +1,127 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class ISourceEventHandler : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal ISourceEventHandler(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(ISourceEventHandler obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~ISourceEventHandler() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_ISourceEventHandler(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public virtual void onUpdate() { + cAudioCSharpWrapperPINVOKE.ISourceEventHandler_onUpdate(swigCPtr); + } + + public virtual void onRelease() { + cAudioCSharpWrapperPINVOKE.ISourceEventHandler_onRelease(swigCPtr); + } + + public virtual void onPlay() { + cAudioCSharpWrapperPINVOKE.ISourceEventHandler_onPlay(swigCPtr); + } + + public virtual void onStop() { + cAudioCSharpWrapperPINVOKE.ISourceEventHandler_onStop(swigCPtr); + } + + public virtual void onPause() { + cAudioCSharpWrapperPINVOKE.ISourceEventHandler_onPause(swigCPtr); + } + + public ISourceEventHandler() : this(cAudioCSharpWrapperPINVOKE.new_ISourceEventHandler(), true) { + SwigDirectorConnect(); + } + + private void SwigDirectorConnect() { + if (SwigDerivedClassHasMethod("onUpdate", swigMethodTypes0)) + swigDelegate0 = new SwigDelegateISourceEventHandler_0(SwigDirectoronUpdate); + if (SwigDerivedClassHasMethod("onRelease", swigMethodTypes1)) + swigDelegate1 = new SwigDelegateISourceEventHandler_1(SwigDirectoronRelease); + if (SwigDerivedClassHasMethod("onPlay", swigMethodTypes2)) + swigDelegate2 = new SwigDelegateISourceEventHandler_2(SwigDirectoronPlay); + if (SwigDerivedClassHasMethod("onStop", swigMethodTypes3)) + swigDelegate3 = new SwigDelegateISourceEventHandler_3(SwigDirectoronStop); + if (SwigDerivedClassHasMethod("onPause", swigMethodTypes4)) + swigDelegate4 = new SwigDelegateISourceEventHandler_4(SwigDirectoronPause); + cAudioCSharpWrapperPINVOKE.ISourceEventHandler_director_connect(swigCPtr, swigDelegate0, swigDelegate1, swigDelegate2, swigDelegate3, swigDelegate4); + } + + private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes) { + System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(methodName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, methodTypes, null); + bool hasDerivedMethod = methodInfo.DeclaringType.IsSubclassOf(typeof(ISourceEventHandler)); + return hasDerivedMethod; + } + + private void SwigDirectoronUpdate() { + onUpdate(); + } + + private void SwigDirectoronRelease() { + onRelease(); + } + + private void SwigDirectoronPlay() { + onPlay(); + } + + private void SwigDirectoronStop() { + onStop(); + } + + private void SwigDirectoronPause() { + onPause(); + } + + public delegate void SwigDelegateISourceEventHandler_0(); + public delegate void SwigDelegateISourceEventHandler_1(); + public delegate void SwigDelegateISourceEventHandler_2(); + public delegate void SwigDelegateISourceEventHandler_3(); + public delegate void SwigDelegateISourceEventHandler_4(); + + private SwigDelegateISourceEventHandler_0 swigDelegate0; + private SwigDelegateISourceEventHandler_1 swigDelegate1; + private SwigDelegateISourceEventHandler_2 swigDelegate2; + private SwigDelegateISourceEventHandler_3 swigDelegate3; + private SwigDelegateISourceEventHandler_4 swigDelegate4; + + private static Type[] swigMethodTypes0 = new Type[] { }; + private static Type[] swigMethodTypes1 = new Type[] { }; + private static Type[] swigMethodTypes2 = new Type[] { }; + private static Type[] swigMethodTypes3 = new Type[] { }; + private static Type[] swigMethodTypes4 = new Type[] { }; +} + +} diff --git a/cAudioCSharp/IThread.cs b/cAudioCSharp/IThread.cs new file mode 100644 index 0000000..c824187 --- /dev/null +++ b/cAudioCSharp/IThread.cs @@ -0,0 +1,64 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IThread : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal IThread(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IThread obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IThread() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IThread(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public virtual bool start() { + bool ret = cAudioCSharpWrapperPINVOKE.IThread_start(swigCPtr); + return ret; + } + + public virtual void join() { + cAudioCSharpWrapperPINVOKE.IThread_join(swigCPtr); + } + + public virtual void shutdown() { + cAudioCSharpWrapperPINVOKE.IThread_shutdown(swigCPtr); + } + + public virtual bool isRunning() { + bool ret = cAudioCSharpWrapperPINVOKE.IThread_isRunning(swigCPtr); + return ret; + } + +} + +} diff --git a/cAudioCSharp/IThreadWorker.cs b/cAudioCSharp/IThreadWorker.cs new file mode 100644 index 0000000..855a1e8 --- /dev/null +++ b/cAudioCSharp/IThreadWorker.cs @@ -0,0 +1,50 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IThreadWorker : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal IThreadWorker(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IThreadWorker obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IThreadWorker() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IThreadWorker(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public virtual void run() { + cAudioCSharpWrapperPINVOKE.IThreadWorker_run(swigCPtr); + } + +} + +} diff --git a/cAudioCSharp/IntVector.cs b/cAudioCSharp/IntVector.cs new file mode 100644 index 0000000..d090482 --- /dev/null +++ b/cAudioCSharp/IntVector.cs @@ -0,0 +1,349 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class IntVector : IDisposable, System.Collections.IEnumerable +#if !SWIG_DOTNET_1 + , System.Collections.Generic.IList +#endif + { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal IntVector(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(IntVector obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~IntVector() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_IntVector(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public IntVector(System.Collections.ICollection c) : this() { + if (c == null) + throw new ArgumentNullException("c"); + foreach (int element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public int this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + +#if SWIG_DOTNET_1 + public void CopyTo(System.Array array) +#else + public void CopyTo(int[] array) +#endif + { + CopyTo(0, array, 0, this.Count); + } + +#if SWIG_DOTNET_1 + public void CopyTo(System.Array array, int arrayIndex) +#else + public void CopyTo(int[] array, int arrayIndex) +#endif + { + CopyTo(0, array, arrayIndex, this.Count); + } + +#if SWIG_DOTNET_1 + public void CopyTo(int index, System.Array array, int arrayIndex, int count) +#else + public void CopyTo(int index, int[] array, int arrayIndex, int count) +#endif + { + if (array == null) + throw new ArgumentNullException("array"); + if (index < 0) + throw new ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new ArgumentException("Number of elements to copy is too large."); + for (int i=0; i System.Collections.Generic.IEnumerable.GetEnumerator() { + return new IntVectorEnumerator(this); + } +#endif + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { + return new IntVectorEnumerator(this); + } + + public IntVectorEnumerator GetEnumerator() { + return new IntVectorEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class IntVectorEnumerator : System.Collections.IEnumerator +#if !SWIG_DOTNET_1 + , System.Collections.Generic.IEnumerator +#endif + { + private IntVector collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public IntVectorEnumerator(IntVector collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public int Current { + get { + if (currentIndex == -1) + throw new InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new InvalidOperationException("Collection modified."); + return (int)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new InvalidOperationException("Collection modified."); + } + } + +#if !SWIG_DOTNET_1 + public void Dispose() { + currentIndex = -1; + currentObject = null; + } +#endif + } + + public void Clear() { + cAudioCSharpWrapperPINVOKE.IntVector_Clear(swigCPtr); + } + + public void Add(int x) { + cAudioCSharpWrapperPINVOKE.IntVector_Add(swigCPtr, x); + } + + private uint size() { + uint ret = cAudioCSharpWrapperPINVOKE.IntVector_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = cAudioCSharpWrapperPINVOKE.IntVector_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + cAudioCSharpWrapperPINVOKE.IntVector_reserve(swigCPtr, n); + } + + public IntVector() : this(cAudioCSharpWrapperPINVOKE.new_IntVector__SWIG_0(), true) { + } + + public IntVector(IntVector other) : this(cAudioCSharpWrapperPINVOKE.new_IntVector__SWIG_1(IntVector.getCPtr(other)), true) { + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public IntVector(int capacity) : this(cAudioCSharpWrapperPINVOKE.new_IntVector__SWIG_2(capacity), true) { + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + private int getitemcopy(int index) { + int ret = cAudioCSharpWrapperPINVOKE.IntVector_getitemcopy(swigCPtr, index); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private int getitem(int index) { + int ret = cAudioCSharpWrapperPINVOKE.IntVector_getitem(swigCPtr, index); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, int val) { + cAudioCSharpWrapperPINVOKE.IntVector_setitem(swigCPtr, index, val); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(IntVector values) { + cAudioCSharpWrapperPINVOKE.IntVector_AddRange(swigCPtr, IntVector.getCPtr(values)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public IntVector GetRange(int index, int count) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IntVector_GetRange(swigCPtr, index, count); + IntVector ret = (cPtr == IntPtr.Zero) ? null : new IntVector(cPtr, true); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, int x) { + cAudioCSharpWrapperPINVOKE.IntVector_Insert(swigCPtr, index, x); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, IntVector values) { + cAudioCSharpWrapperPINVOKE.IntVector_InsertRange(swigCPtr, index, IntVector.getCPtr(values)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + cAudioCSharpWrapperPINVOKE.IntVector_RemoveAt(swigCPtr, index); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + cAudioCSharpWrapperPINVOKE.IntVector_RemoveRange(swigCPtr, index, count); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public static IntVector Repeat(int value, int count) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.IntVector_Repeat(value, count); + IntVector ret = (cPtr == IntPtr.Zero) ? null : new IntVector(cPtr, true); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + cAudioCSharpWrapperPINVOKE.IntVector_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + cAudioCSharpWrapperPINVOKE.IntVector_Reverse__SWIG_1(swigCPtr, index, count); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, IntVector values) { + cAudioCSharpWrapperPINVOKE.IntVector_SetRange(swigCPtr, index, IntVector.getCPtr(values)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(int value) { + bool ret = cAudioCSharpWrapperPINVOKE.IntVector_Contains(swigCPtr, value); + return ret; + } + + public int IndexOf(int value) { + int ret = cAudioCSharpWrapperPINVOKE.IntVector_IndexOf(swigCPtr, value); + return ret; + } + + public int LastIndexOf(int value) { + int ret = cAudioCSharpWrapperPINVOKE.IntVector_LastIndexOf(swigCPtr, value); + return ret; + } + + public bool Remove(int value) { + bool ret = cAudioCSharpWrapperPINVOKE.IntVector_Remove(swigCPtr, value); + return ret; + } + +} + +} diff --git a/cAudioCSharp/LogLevel.cs b/cAudioCSharp/LogLevel.cs new file mode 100644 index 0000000..9ca0dab --- /dev/null +++ b/cAudioCSharp/LogLevel.cs @@ -0,0 +1,20 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +public enum LogLevel { + ELL_DEBUG, + ELL_INFO, + ELL_WARNING, + ELL_ERROR, + ELL_CRITICAL, + ELL_COUNT +} + +} diff --git a/cAudioCSharp/Properties/AssemblyInfo.cs b/cAudioCSharp/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..1ba6049 --- /dev/null +++ b/cAudioCSharp/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("cAudioCSharp")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("cAudioCSharp")] +[assembly: AssemblyCopyright("Copyright © 2011")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("4cc84d4a-a0ff-4cd9-b656-e8e0dac657b9")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/cAudioCSharp/SWIGTYPE_p_AudioFormats.cs b/cAudioCSharp/SWIGTYPE_p_AudioFormats.cs new file mode 100644 index 0000000..9ec27c1 --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_AudioFormats.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_AudioFormats { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_AudioFormats(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_AudioFormats() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_AudioFormats obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_IAudioCapture.cs b/cAudioCSharp/SWIGTYPE_p_IAudioCapture.cs new file mode 100644 index 0000000..5d9b929 --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_IAudioCapture.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_IAudioCapture { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_IAudioCapture(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_IAudioCapture() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_IAudioCapture obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_IDataSourceFactory.cs b/cAudioCSharp/SWIGTYPE_p_IDataSourceFactory.cs new file mode 100644 index 0000000..a54a8c6 --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_IDataSourceFactory.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_IDataSourceFactory { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_IDataSourceFactory(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_IDataSourceFactory() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_IDataSourceFactory obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_IListener.cs b/cAudioCSharp/SWIGTYPE_p_IListener.cs new file mode 100644 index 0000000..666dc88 --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_IListener.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_IListener { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_IListener(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_IListener() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_IListener obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_ILogReceiver.cs b/cAudioCSharp/SWIGTYPE_p_ILogReceiver.cs new file mode 100644 index 0000000..418683a --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_ILogReceiver.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_ILogReceiver { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_ILogReceiver(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_ILogReceiver() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_ILogReceiver obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_ILogger.cs b/cAudioCSharp/SWIGTYPE_p_ILogger.cs new file mode 100644 index 0000000..f366167 --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_ILogger.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_ILogger { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_ILogger(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_ILogger() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_ILogger obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_IManagerEventHandler.cs b/cAudioCSharp/SWIGTYPE_p_IManagerEventHandler.cs new file mode 100644 index 0000000..8803c56 --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_IManagerEventHandler.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_IManagerEventHandler { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_IManagerEventHandler(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_IManagerEventHandler() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_IManagerEventHandler obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_ISourceEventHandler.cs b/cAudioCSharp/SWIGTYPE_p_ISourceEventHandler.cs new file mode 100644 index 0000000..24e1f5e --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_ISourceEventHandler.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_ISourceEventHandler { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_ISourceEventHandler(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_ISourceEventHandler() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_ISourceEventHandler obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_LogLevel.cs b/cAudioCSharp/SWIGTYPE_p_LogLevel.cs new file mode 100644 index 0000000..51edff1 --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_LogLevel.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_LogLevel { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_LogLevel(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_LogLevel() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_LogLevel obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_cVector3.cs b/cAudioCSharp/SWIGTYPE_p_cVector3.cs new file mode 100644 index 0000000..ef8d07b --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_cVector3.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_cVector3 { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_cVector3(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_cVector3() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_cVector3 obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_float.cs b/cAudioCSharp/SWIGTYPE_p_float.cs new file mode 100644 index 0000000..a6441fe --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_float.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_float { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_float(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_float() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_float obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_p_char.cs b/cAudioCSharp/SWIGTYPE_p_p_char.cs new file mode 100644 index 0000000..06aadbd --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_p_char.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_p_char { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_p_char(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_p_char() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_p_char obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_std__basic_stringT_char_t.cs b/cAudioCSharp/SWIGTYPE_p_std__basic_stringT_char_t.cs new file mode 100644 index 0000000..192b81e --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_std__basic_stringT_char_t.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_std__basic_stringT_char_t { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_std__basic_stringT_char_t(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_std__basic_stringT_char_t() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_std__basic_stringT_char_t obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/SWIGTYPE_p_void.cs b/cAudioCSharp/SWIGTYPE_p_void.cs new file mode 100644 index 0000000..d2d7312 --- /dev/null +++ b/cAudioCSharp/SWIGTYPE_p_void.cs @@ -0,0 +1,30 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_void { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_void(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_void() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_void obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} diff --git a/cAudioCSharp/StringMap.cs b/cAudioCSharp/StringMap.cs new file mode 100644 index 0000000..6be5bd3 --- /dev/null +++ b/cAudioCSharp/StringMap.cs @@ -0,0 +1,296 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class StringMap : IDisposable +#if !SWIG_DOTNET_1 + , System.Collections.Generic.IDictionary +#endif + { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal StringMap(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(StringMap obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~StringMap() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_StringMap(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + + public string this[string key] { + get { + return getitem(key); + } + + set { + setitem(key, value); + } + } + + public bool TryGetValue(string key, out string value) { + if (this.ContainsKey(key)) { + value = this[key]; + return true; + } + value = default(string); + return false; + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsReadOnly { + get { + return false; + } + } + +#if !SWIG_DOTNET_1 + + public System.Collections.Generic.ICollection Keys { + get { + System.Collections.Generic.ICollection keys = new System.Collections.Generic.List(); + int size = this.Count; + if (size > 0) { + IntPtr iter = create_iterator_begin(); + for (int i = 0; i < size; i++) { + keys.Add(get_next_key(iter)); + } + destroy_iterator(iter); + } + return keys; + } + } + + public System.Collections.Generic.ICollection Values { + get { + System.Collections.Generic.ICollection vals = new System.Collections.Generic.List(); + foreach (System.Collections.Generic.KeyValuePair pair in this) { + vals.Add(pair.Value); + } + return vals; + } + } + + public void Add(System.Collections.Generic.KeyValuePair item) { + Add(item.Key, item.Value); + } + + public bool Remove(System.Collections.Generic.KeyValuePair item) { + if (Contains(item)) { + return Remove(item.Key); + } else { + return false; + } + } + + public bool Contains(System.Collections.Generic.KeyValuePair item) { + if (this[item.Key] == item.Value) { + return true; + } else { + return false; + } + } + + public void CopyTo(System.Collections.Generic.KeyValuePair[] array) { + CopyTo(array, 0); + } + + public void CopyTo(System.Collections.Generic.KeyValuePair[] array, int arrayIndex) { + if (array == null) + throw new ArgumentNullException("array"); + if (arrayIndex < 0) + throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (array.Rank > 1) + throw new ArgumentException("Multi dimensional array.", "array"); + if (arrayIndex+this.Count > array.Length) + throw new ArgumentException("Number of elements to copy is too large."); + + System.Collections.Generic.IList keyList = new System.Collections.Generic.List(this.Keys); + for (int i = 0; i < keyList.Count; i++) { + string currentKey = keyList[i]; + array.SetValue(new System.Collections.Generic.KeyValuePair(currentKey, this[currentKey]), arrayIndex+i); + } + } + + System.Collections.Generic.IEnumerator> System.Collections.Generic.IEnumerable>.GetEnumerator() { + return new StringMapEnumerator(this); + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { + return new StringMapEnumerator(this); + } + + public StringMapEnumerator GetEnumerator() { + return new StringMapEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class StringMapEnumerator : System.Collections.IEnumerator, + System.Collections.Generic.IEnumerator> + { + private StringMap collectionRef; + private System.Collections.Generic.IList keyCollection; + private int currentIndex; + private object currentObject; + private int currentSize; + + public StringMapEnumerator(StringMap collection) { + collectionRef = collection; + keyCollection = new System.Collections.Generic.List(collection.Keys); + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public System.Collections.Generic.KeyValuePair Current { + get { + if (currentIndex == -1) + throw new InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new InvalidOperationException("Collection modified."); + return (System.Collections.Generic.KeyValuePair)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + string currentKey = keyCollection[currentIndex]; + currentObject = new System.Collections.Generic.KeyValuePair(currentKey, collectionRef[currentKey]); + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } +#endif + + + public StringMap() : this(cAudioCSharpWrapperPINVOKE.new_StringMap__SWIG_0(), true) { + } + + public StringMap(StringMap other) : this(cAudioCSharpWrapperPINVOKE.new_StringMap__SWIG_1(StringMap.getCPtr(other)), true) { + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = cAudioCSharpWrapperPINVOKE.StringMap_size(swigCPtr); + return ret; + } + + public bool empty() { + bool ret = cAudioCSharpWrapperPINVOKE.StringMap_empty(swigCPtr); + return ret; + } + + public void Clear() { + cAudioCSharpWrapperPINVOKE.StringMap_Clear(swigCPtr); + } + + private string getitem(string key) { + string ret = cAudioCSharpWrapperPINVOKE.StringMap_getitem(swigCPtr, key); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(string key, string x) { + cAudioCSharpWrapperPINVOKE.StringMap_setitem(swigCPtr, key, x); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool ContainsKey(string key) { + bool ret = cAudioCSharpWrapperPINVOKE.StringMap_ContainsKey(swigCPtr, key); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Add(string key, string val) { + cAudioCSharpWrapperPINVOKE.StringMap_Add(swigCPtr, key, val); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Remove(string key) { + bool ret = cAudioCSharpWrapperPINVOKE.StringMap_Remove(swigCPtr, key); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private IntPtr create_iterator_begin() { + IntPtr ret = cAudioCSharpWrapperPINVOKE.StringMap_create_iterator_begin(swigCPtr); + return ret; + } + + private string get_next_key(IntPtr swigiterator) { + string ret = cAudioCSharpWrapperPINVOKE.StringMap_get_next_key(swigCPtr, swigiterator); + return ret; + } + + private void destroy_iterator(IntPtr swigiterator) { + cAudioCSharpWrapperPINVOKE.StringMap_destroy_iterator(swigCPtr, swigiterator); + } + +} + +} diff --git a/cAudioCSharp/StringVector.cs b/cAudioCSharp/StringVector.cs new file mode 100644 index 0000000..60ab852 --- /dev/null +++ b/cAudioCSharp/StringVector.cs @@ -0,0 +1,354 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class StringVector : IDisposable, System.Collections.IEnumerable +#if !SWIG_DOTNET_1 + , System.Collections.Generic.IList +#endif + { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal StringVector(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(StringVector obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~StringVector() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_StringVector(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public StringVector(System.Collections.ICollection c) : this() { + if (c == null) + throw new ArgumentNullException("c"); + foreach (string element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public string this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + +#if SWIG_DOTNET_1 + public void CopyTo(System.Array array) +#else + public void CopyTo(string[] array) +#endif + { + CopyTo(0, array, 0, this.Count); + } + +#if SWIG_DOTNET_1 + public void CopyTo(System.Array array, int arrayIndex) +#else + public void CopyTo(string[] array, int arrayIndex) +#endif + { + CopyTo(0, array, arrayIndex, this.Count); + } + +#if SWIG_DOTNET_1 + public void CopyTo(int index, System.Array array, int arrayIndex, int count) +#else + public void CopyTo(int index, string[] array, int arrayIndex, int count) +#endif + { + if (array == null) + throw new ArgumentNullException("array"); + if (index < 0) + throw new ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new ArgumentException("Number of elements to copy is too large."); + for (int i=0; i System.Collections.Generic.IEnumerable.GetEnumerator() { + return new StringVectorEnumerator(this); + } +#endif + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { + return new StringVectorEnumerator(this); + } + + public StringVectorEnumerator GetEnumerator() { + return new StringVectorEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class StringVectorEnumerator : System.Collections.IEnumerator +#if !SWIG_DOTNET_1 + , System.Collections.Generic.IEnumerator +#endif + { + private StringVector collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public StringVectorEnumerator(StringVector collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public string Current { + get { + if (currentIndex == -1) + throw new InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new InvalidOperationException("Collection modified."); + return (string)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new InvalidOperationException("Collection modified."); + } + } + +#if !SWIG_DOTNET_1 + public void Dispose() { + currentIndex = -1; + currentObject = null; + } +#endif + } + + public void Clear() { + cAudioCSharpWrapperPINVOKE.StringVector_Clear(swigCPtr); + } + + public void Add(string x) { + cAudioCSharpWrapperPINVOKE.StringVector_Add(swigCPtr, x); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = cAudioCSharpWrapperPINVOKE.StringVector_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = cAudioCSharpWrapperPINVOKE.StringVector_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + cAudioCSharpWrapperPINVOKE.StringVector_reserve(swigCPtr, n); + } + + public StringVector() : this(cAudioCSharpWrapperPINVOKE.new_StringVector__SWIG_0(), true) { + } + + public StringVector(StringVector other) : this(cAudioCSharpWrapperPINVOKE.new_StringVector__SWIG_1(StringVector.getCPtr(other)), true) { + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public StringVector(int capacity) : this(cAudioCSharpWrapperPINVOKE.new_StringVector__SWIG_2(capacity), true) { + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + private string getitemcopy(int index) { + string ret = cAudioCSharpWrapperPINVOKE.StringVector_getitemcopy(swigCPtr, index); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private string getitem(int index) { + string ret = cAudioCSharpWrapperPINVOKE.StringVector_getitem(swigCPtr, index); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, string val) { + cAudioCSharpWrapperPINVOKE.StringVector_setitem(swigCPtr, index, val); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(StringVector values) { + cAudioCSharpWrapperPINVOKE.StringVector_AddRange(swigCPtr, StringVector.getCPtr(values)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public StringVector GetRange(int index, int count) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.StringVector_GetRange(swigCPtr, index, count); + StringVector ret = (cPtr == IntPtr.Zero) ? null : new StringVector(cPtr, true); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, string x) { + cAudioCSharpWrapperPINVOKE.StringVector_Insert(swigCPtr, index, x); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, StringVector values) { + cAudioCSharpWrapperPINVOKE.StringVector_InsertRange(swigCPtr, index, StringVector.getCPtr(values)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + cAudioCSharpWrapperPINVOKE.StringVector_RemoveAt(swigCPtr, index); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + cAudioCSharpWrapperPINVOKE.StringVector_RemoveRange(swigCPtr, index, count); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public static StringVector Repeat(string value, int count) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.StringVector_Repeat(value, count); + StringVector ret = (cPtr == IntPtr.Zero) ? null : new StringVector(cPtr, true); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + cAudioCSharpWrapperPINVOKE.StringVector_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + cAudioCSharpWrapperPINVOKE.StringVector_Reverse__SWIG_1(swigCPtr, index, count); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, StringVector values) { + cAudioCSharpWrapperPINVOKE.StringVector_SetRange(swigCPtr, index, StringVector.getCPtr(values)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(string value) { + bool ret = cAudioCSharpWrapperPINVOKE.StringVector_Contains(swigCPtr, value); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public int IndexOf(string value) { + int ret = cAudioCSharpWrapperPINVOKE.StringVector_IndexOf(swigCPtr, value); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public int LastIndexOf(string value) { + int ret = cAudioCSharpWrapperPINVOKE.StringVector_LastIndexOf(swigCPtr, value); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool Remove(string value) { + bool ret = cAudioCSharpWrapperPINVOKE.StringVector_Remove(swigCPtr, value); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + +} + +} diff --git a/cAudioCSharp/cAudioCSharp.csproj b/cAudioCSharp/cAudioCSharp.csproj new file mode 100644 index 0000000..fa857ba --- /dev/null +++ b/cAudioCSharp/cAudioCSharp.csproj @@ -0,0 +1,85 @@ + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {4DDC8FD9-BEAF-422E-A28E-093D299F7DEF} + Library + Properties + cAudioCSharp + cAudioCSharp + v4.0 + 512 + + + x86 + bin\x86\Debug\ + + + x86 + bin\x86\Release\ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/cAudioCSharp/cAudioCSharpWrapper.cs b/cAudioCSharp/cAudioCSharpWrapper.cs new file mode 100644 index 0000000..aade96b --- /dev/null +++ b/cAudioCSharp/cAudioCSharpWrapper.cs @@ -0,0 +1,130 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class cAudioCSharpWrapper { + public static SWIGTYPE_p_p_char LogLevelStrings { + get { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.LogLevelStrings_get(); + SWIGTYPE_p_p_char ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_char(cPtr, false); + return ret; + } + } + + public static IAudioManager createAudioManager(bool initializeDefault) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.createAudioManager__SWIG_0(initializeDefault); + IAudioManager ret = (cPtr == IntPtr.Zero) ? null : new IAudioManager(cPtr, false); + return ret; + } + + public static IAudioManager createAudioManager() { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.createAudioManager__SWIG_1(); + IAudioManager ret = (cPtr == IntPtr.Zero) ? null : new IAudioManager(cPtr, false); + return ret; + } + + public static void destroyAudioManager(IAudioManager manager) { + cAudioCSharpWrapperPINVOKE.destroyAudioManager(IAudioManager.getCPtr(manager)); + } + + public static SWIGTYPE_p_IAudioCapture createAudioCapture(bool initializeDefault) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.createAudioCapture__SWIG_0(initializeDefault); + SWIGTYPE_p_IAudioCapture ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_IAudioCapture(cPtr, false); + return ret; + } + + public static SWIGTYPE_p_IAudioCapture createAudioCapture() { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.createAudioCapture__SWIG_1(); + SWIGTYPE_p_IAudioCapture ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_IAudioCapture(cPtr, false); + return ret; + } + + public static void destroyAudioCapture(SWIGTYPE_p_IAudioCapture capture) { + cAudioCSharpWrapperPINVOKE.destroyAudioCapture(SWIGTYPE_p_IAudioCapture.getCPtr(capture)); + } + + public static ILogger getLogger() { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.getLogger(); + ILogger ret = (cPtr == IntPtr.Zero) ? null : new ILogger(cPtr, false); + return ret; + } + + public static IMemoryProvider getMemoryProvider() { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.getMemoryProvider(); + IMemoryProvider ret = (cPtr == IntPtr.Zero) ? null : new IMemoryProvider(cPtr, false); + return ret; + } + + public static void cAudioSleep(uint ms) { + cAudioCSharpWrapperPINVOKE.cAudioSleep(ms); + } + + public static string toWINSTR(string str) { + string ret = cAudioCSharpWrapperPINVOKE.toWINSTR(str); + return ret; + } + + public static string toUTF8(SWIGTYPE_p_std__basic_stringT_char_t str) { + string ret = cAudioCSharpWrapperPINVOKE.toUTF8(SWIGTYPE_p_std__basic_stringT_char_t.getCPtr(str)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static SWIGTYPE_p_std__basic_stringT_char_t fromUTF8(string str) { + SWIGTYPE_p_std__basic_stringT_char_t ret = new SWIGTYPE_p_std__basic_stringT_char_t(cAudioCSharpWrapperPINVOKE.fromUTF8(str), true); + return ret; + } + + public static float Epsilon { + get { + float ret = cAudioCSharpWrapperPINVOKE.Epsilon_get(); + return ret; + } + } + + public static bool float_equals(float a, float b) { + bool ret = cAudioCSharpWrapperPINVOKE.float_equals(a, b); + return ret; + } + + public static SWIGTYPE_p_float new_floatp() { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.new_floatp(); + SWIGTYPE_p_float ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_float(cPtr, false); + return ret; + } + + public static SWIGTYPE_p_float copy_floatp(float value) { + IntPtr cPtr = cAudioCSharpWrapperPINVOKE.copy_floatp(value); + SWIGTYPE_p_float ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_float(cPtr, false); + return ret; + } + + public static void delete_floatp(SWIGTYPE_p_float self) { + cAudioCSharpWrapperPINVOKE.delete_floatp(SWIGTYPE_p_float.getCPtr(self)); + } + + public static void floatp_assign(SWIGTYPE_p_float self, float value) { + cAudioCSharpWrapperPINVOKE.floatp_assign(SWIGTYPE_p_float.getCPtr(self), value); + } + + public static float floatp_value(SWIGTYPE_p_float self) { + float ret = cAudioCSharpWrapperPINVOKE.floatp_value(SWIGTYPE_p_float.getCPtr(self)); + return ret; + } + + public static readonly string CAUDIO_VERSION = cAudioCSharpWrapperPINVOKE.CAUDIO_VERSION_get(); + public static readonly int CAUDIO_SOURCE_BUFFER_SIZE = cAudioCSharpWrapperPINVOKE.CAUDIO_SOURCE_BUFFER_SIZE_get(); + public static readonly int CAUDIO_SOURCE_NUM_BUFFERS = cAudioCSharpWrapperPINVOKE.CAUDIO_SOURCE_NUM_BUFFERS_get(); + public static readonly int CAUDIO_SOURCE_MAX_EFFECT_SLOTS = cAudioCSharpWrapperPINVOKE.CAUDIO_SOURCE_MAX_EFFECT_SLOTS_get(); +} + +} diff --git a/cAudioCSharp/cAudioCSharpWrapperPINVOKE.cs b/cAudioCSharp/cAudioCSharpWrapperPINVOKE.cs new file mode 100644 index 0000000..04be906 --- /dev/null +++ b/cAudioCSharp/cAudioCSharpWrapperPINVOKE.cs @@ -0,0 +1,1387 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +class cAudioCSharpWrapperPINVOKE { + + protected class SWIGExceptionHelper { + + public delegate void ExceptionDelegate(string message); + public delegate void ExceptionArgumentDelegate(string message, string paramName); + + static ExceptionDelegate applicationDelegate = new ExceptionDelegate(SetPendingApplicationException); + static ExceptionDelegate arithmeticDelegate = new ExceptionDelegate(SetPendingArithmeticException); + static ExceptionDelegate divideByZeroDelegate = new ExceptionDelegate(SetPendingDivideByZeroException); + static ExceptionDelegate indexOutOfRangeDelegate = new ExceptionDelegate(SetPendingIndexOutOfRangeException); + static ExceptionDelegate invalidCastDelegate = new ExceptionDelegate(SetPendingInvalidCastException); + static ExceptionDelegate invalidOperationDelegate = new ExceptionDelegate(SetPendingInvalidOperationException); + static ExceptionDelegate ioDelegate = new ExceptionDelegate(SetPendingIOException); + static ExceptionDelegate nullReferenceDelegate = new ExceptionDelegate(SetPendingNullReferenceException); + static ExceptionDelegate outOfMemoryDelegate = new ExceptionDelegate(SetPendingOutOfMemoryException); + static ExceptionDelegate overflowDelegate = new ExceptionDelegate(SetPendingOverflowException); + static ExceptionDelegate systemDelegate = new ExceptionDelegate(SetPendingSystemException); + + static ExceptionArgumentDelegate argumentDelegate = new ExceptionArgumentDelegate(SetPendingArgumentException); + static ExceptionArgumentDelegate argumentNullDelegate = new ExceptionArgumentDelegate(SetPendingArgumentNullException); + static ExceptionArgumentDelegate argumentOutOfRangeDelegate = new ExceptionArgumentDelegate(SetPendingArgumentOutOfRangeException); + + [DllImport("cAudioCSharpWrapper", EntryPoint="SWIGRegisterExceptionCallbacks_cAudioCSharpWrapper")] + public static extern void SWIGRegisterExceptionCallbacks_cAudioCSharpWrapper( + ExceptionDelegate applicationDelegate, + ExceptionDelegate arithmeticDelegate, + ExceptionDelegate divideByZeroDelegate, + ExceptionDelegate indexOutOfRangeDelegate, + ExceptionDelegate invalidCastDelegate, + ExceptionDelegate invalidOperationDelegate, + ExceptionDelegate ioDelegate, + ExceptionDelegate nullReferenceDelegate, + ExceptionDelegate outOfMemoryDelegate, + ExceptionDelegate overflowDelegate, + ExceptionDelegate systemExceptionDelegate); + + [DllImport("cAudioCSharpWrapper", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_cAudioCSharpWrapper")] + public static extern void SWIGRegisterExceptionCallbacksArgument_cAudioCSharpWrapper( + ExceptionArgumentDelegate argumentDelegate, + ExceptionArgumentDelegate argumentNullDelegate, + ExceptionArgumentDelegate argumentOutOfRangeDelegate); + + static void SetPendingApplicationException(string message) { + SWIGPendingException.Set(new System.ApplicationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingArithmeticException(string message) { + SWIGPendingException.Set(new System.ArithmeticException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingDivideByZeroException(string message) { + SWIGPendingException.Set(new System.DivideByZeroException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIndexOutOfRangeException(string message) { + SWIGPendingException.Set(new System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidCastException(string message) { + SWIGPendingException.Set(new System.InvalidCastException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidOperationException(string message) { + SWIGPendingException.Set(new System.InvalidOperationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIOException(string message) { + SWIGPendingException.Set(new System.IO.IOException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingNullReferenceException(string message) { + SWIGPendingException.Set(new System.NullReferenceException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOutOfMemoryException(string message) { + SWIGPendingException.Set(new System.OutOfMemoryException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOverflowException(string message) { + SWIGPendingException.Set(new System.OverflowException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingSystemException(string message) { + SWIGPendingException.Set(new System.SystemException(message, SWIGPendingException.Retrieve())); + } + + static void SetPendingArgumentException(string message, string paramName) { + SWIGPendingException.Set(new System.ArgumentException(message, paramName, SWIGPendingException.Retrieve())); + } + static void SetPendingArgumentNullException(string message, string paramName) { + Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new System.ArgumentNullException(paramName, message)); + } + static void SetPendingArgumentOutOfRangeException(string message, string paramName) { + Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new System.ArgumentOutOfRangeException(paramName, message)); + } + + static SWIGExceptionHelper() { + SWIGRegisterExceptionCallbacks_cAudioCSharpWrapper( + applicationDelegate, + arithmeticDelegate, + divideByZeroDelegate, + indexOutOfRangeDelegate, + invalidCastDelegate, + invalidOperationDelegate, + ioDelegate, + nullReferenceDelegate, + outOfMemoryDelegate, + overflowDelegate, + systemDelegate); + + SWIGRegisterExceptionCallbacksArgument_cAudioCSharpWrapper( + argumentDelegate, + argumentNullDelegate, + argumentOutOfRangeDelegate); + } + } + + protected static SWIGExceptionHelper swigExceptionHelper = new SWIGExceptionHelper(); + + public class SWIGPendingException { + [ThreadStatic] + private static Exception pendingException = null; + private static int numExceptionsPending = 0; + + public static bool Pending { + get { + bool pending = false; + if (numExceptionsPending > 0) + if (pendingException != null) + pending = true; + return pending; + } + } + + public static void Set(Exception e) { + if (pendingException != null) + throw new ApplicationException("FATAL: An earlier pending exception from unmanaged code was missed and thus not thrown (" + pendingException.ToString() + ")", e); + pendingException = e; + lock(typeof(cAudioCSharpWrapperPINVOKE)) { + numExceptionsPending++; + } + } + + public static Exception Retrieve() { + Exception e = null; + if (numExceptionsPending > 0) { + if (pendingException != null) { + e = pendingException; + pendingException = null; + lock(typeof(cAudioCSharpWrapperPINVOKE)) { + numExceptionsPending--; + } + } + } + return e; + } + } + + + protected class SWIGStringHelper { + + public delegate string SWIGStringDelegate(string message); + static SWIGStringDelegate stringDelegate = new SWIGStringDelegate(CreateString); + + [DllImport("cAudioCSharpWrapper", EntryPoint="SWIGRegisterStringCallback_cAudioCSharpWrapper")] + public static extern void SWIGRegisterStringCallback_cAudioCSharpWrapper(SWIGStringDelegate stringDelegate); + + static string CreateString(string cString) { + return cString; + } + + static SWIGStringHelper() { + SWIGRegisterStringCallback_cAudioCSharpWrapper(stringDelegate); + } + } + + static protected SWIGStringHelper swigStringHelper = new SWIGStringHelper(); + + + static cAudioCSharpWrapperPINVOKE() { + } + + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_IRefCounted")] + public static extern IntPtr new_IRefCounted(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IRefCounted")] + public static extern void delete_IRefCounted(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IRefCounted_grab")] + public static extern void IRefCounted_grab(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IRefCounted_drop")] + public static extern bool IRefCounted_drop(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IRefCounted_getReferenceCount")] + public static extern int IRefCounted_getReferenceCount(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IAudioManager")] + public static extern void delete_IAudioManager(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_initialize__SWIG_0")] + public static extern bool IAudioManager_initialize__SWIG_0(HandleRef jarg1, string jarg2, int jarg3, int jarg4); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_initialize__SWIG_1")] + public static extern bool IAudioManager_initialize__SWIG_1(HandleRef jarg1, string jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_initialize__SWIG_2")] + public static extern bool IAudioManager_initialize__SWIG_2(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_initialize__SWIG_3")] + public static extern bool IAudioManager_initialize__SWIG_3(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_shutDown")] + public static extern void IAudioManager_shutDown(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_update")] + public static extern void IAudioManager_update(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_isUpdateThreadRunning")] + public static extern bool IAudioManager_isUpdateThreadRunning(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_getSoundByName")] + public static extern IntPtr IAudioManager_getSoundByName(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_releaseAllSources")] + public static extern void IAudioManager_releaseAllSources(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_release")] + public static extern void IAudioManager_release(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_getAvailableDeviceName")] + public static extern string IAudioManager_getAvailableDeviceName(HandleRef jarg1, uint jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_getAvailableDeviceCount")] + public static extern uint IAudioManager_getAvailableDeviceCount(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_getDefaultDeviceName")] + public static extern string IAudioManager_getDefaultDeviceName(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_create__SWIG_0")] + public static extern IntPtr IAudioManager_create__SWIG_0(HandleRef jarg1, string jarg2, string jarg3, bool jarg4); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_create__SWIG_1")] + public static extern IntPtr IAudioManager_create__SWIG_1(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_createFromMemory")] + public static extern IntPtr IAudioManager_createFromMemory(HandleRef jarg1, string jarg2, string jarg3, uint jarg4, string jarg5); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_createFromRaw")] + public static extern IntPtr IAudioManager_createFromRaw(HandleRef jarg1, string jarg2, string jarg3, uint jarg4, uint jarg5, HandleRef jarg6); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_registerAudioDecoder")] + public static extern bool IAudioManager_registerAudioDecoder(HandleRef jarg1, HandleRef jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_unRegisterAudioDecoder")] + public static extern void IAudioManager_unRegisterAudioDecoder(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_isAudioDecoderRegistered")] + public static extern bool IAudioManager_isAudioDecoderRegistered(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_getAudioDecoderFactory")] + public static extern IntPtr IAudioManager_getAudioDecoderFactory(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_unRegisterAllAudioDecoders")] + public static extern void IAudioManager_unRegisterAllAudioDecoders(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_registerDataSource")] + public static extern bool IAudioManager_registerDataSource(HandleRef jarg1, HandleRef jarg2, string jarg3, int jarg4); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_unRegisterDataSource")] + public static extern void IAudioManager_unRegisterDataSource(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_isDataSourceRegistered")] + public static extern bool IAudioManager_isDataSourceRegistered(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_getDataSourceFactory")] + public static extern IntPtr IAudioManager_getDataSourceFactory(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_unRegisterAllDataSources")] + public static extern void IAudioManager_unRegisterAllDataSources(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_registerEventHandler")] + public static extern void IAudioManager_registerEventHandler(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_unRegisterEventHandler")] + public static extern void IAudioManager_unRegisterEventHandler(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_unRegisterAllEventHandlers")] + public static extern void IAudioManager_unRegisterAllEventHandlers(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioManager_getListener")] + public static extern IntPtr IAudioManager_getListener(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IAudioPlugin")] + public static extern void delete_IAudioPlugin(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioPlugin_installPlugin")] + public static extern bool IAudioPlugin_installPlugin(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioPlugin_getPluginName")] + public static extern string IAudioPlugin_getPluginName(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioPlugin_uninstallPlugin")] + public static extern void IAudioPlugin_uninstallPlugin(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioPlugin_onCreateAudioManager")] + public static extern void IAudioPlugin_onCreateAudioManager(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioPlugin_onCreateAudioCapture")] + public static extern void IAudioPlugin_onCreateAudioCapture(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioPlugin_onDestroyAudioManager")] + public static extern void IAudioPlugin_onDestroyAudioManager(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioPlugin_onDestoryAudioCapture")] + public static extern void IAudioPlugin_onDestoryAudioCapture(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IAudioSource")] + public static extern void delete_IAudioSource(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_play")] + public static extern bool IAudioSource_play(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_play2d__SWIG_0")] + public static extern bool IAudioSource_play2d__SWIG_0(HandleRef jarg1, bool jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_play2d__SWIG_1")] + public static extern bool IAudioSource_play2d__SWIG_1(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_play3d__SWIG_0")] + public static extern bool IAudioSource_play3d__SWIG_0(HandleRef jarg1, HandleRef jarg2, float jarg3, bool jarg4); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_play3d__SWIG_1")] + public static extern bool IAudioSource_play3d__SWIG_1(HandleRef jarg1, HandleRef jarg2, float jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_play3d__SWIG_2")] + public static extern bool IAudioSource_play3d__SWIG_2(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_pause")] + public static extern void IAudioSource_pause(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_stop")] + public static extern void IAudioSource_stop(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_loop")] + public static extern void IAudioSource_loop(HandleRef jarg1, bool jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_seek__SWIG_0")] + public static extern bool IAudioSource_seek__SWIG_0(HandleRef jarg1, float jarg2, bool jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_seek__SWIG_1")] + public static extern bool IAudioSource_seek__SWIG_1(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getTotalAudioTime")] + public static extern float IAudioSource_getTotalAudioTime(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getTotalAudioSize")] + public static extern int IAudioSource_getTotalAudioSize(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getCompressedAudioSize")] + public static extern int IAudioSource_getCompressedAudioSize(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getCurrentAudioTime")] + public static extern float IAudioSource_getCurrentAudioTime(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getCurrentAudioPosition")] + public static extern int IAudioSource_getCurrentAudioPosition(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getCurrentCompressedAudioPosition")] + public static extern int IAudioSource_getCurrentCompressedAudioPosition(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_update")] + public static extern bool IAudioSource_update(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_release")] + public static extern void IAudioSource_release(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_isValid")] + public static extern bool IAudioSource_isValid(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_isPlaying")] + public static extern bool IAudioSource_isPlaying(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_isPaused")] + public static extern bool IAudioSource_isPaused(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_isStopped")] + public static extern bool IAudioSource_isStopped(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_isLooping")] + public static extern bool IAudioSource_isLooping(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setPosition")] + public static extern void IAudioSource_setPosition(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setVelocity")] + public static extern void IAudioSource_setVelocity(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setDirection")] + public static extern void IAudioSource_setDirection(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setRolloffFactor")] + public static extern void IAudioSource_setRolloffFactor(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setStrength")] + public static extern void IAudioSource_setStrength(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setMinDistance")] + public static extern void IAudioSource_setMinDistance(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setMaxDistance")] + public static extern void IAudioSource_setMaxDistance(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setPitch")] + public static extern void IAudioSource_setPitch(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setVolume")] + public static extern void IAudioSource_setVolume(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setMinVolume")] + public static extern void IAudioSource_setMinVolume(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setMaxVolume")] + public static extern void IAudioSource_setMaxVolume(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setInnerConeAngle")] + public static extern void IAudioSource_setInnerConeAngle(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setOuterConeAngle")] + public static extern void IAudioSource_setOuterConeAngle(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setOuterConeVolume")] + public static extern void IAudioSource_setOuterConeVolume(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setDopplerStrength")] + public static extern void IAudioSource_setDopplerStrength(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_setDopplerVelocity")] + public static extern void IAudioSource_setDopplerVelocity(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_move")] + public static extern void IAudioSource_move(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getPosition")] + public static extern IntPtr IAudioSource_getPosition(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getVelocity")] + public static extern IntPtr IAudioSource_getVelocity(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getDirection")] + public static extern IntPtr IAudioSource_getDirection(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getRolloffFactor")] + public static extern float IAudioSource_getRolloffFactor(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getStrength")] + public static extern float IAudioSource_getStrength(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getMinDistance")] + public static extern float IAudioSource_getMinDistance(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getMaxDistance")] + public static extern float IAudioSource_getMaxDistance(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getPitch")] + public static extern float IAudioSource_getPitch(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getVolume")] + public static extern float IAudioSource_getVolume(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getMinVolume")] + public static extern float IAudioSource_getMinVolume(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getMaxVolume")] + public static extern float IAudioSource_getMaxVolume(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getInnerConeAngle")] + public static extern float IAudioSource_getInnerConeAngle(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getOuterConeAngle")] + public static extern float IAudioSource_getOuterConeAngle(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getOuterConeVolume")] + public static extern float IAudioSource_getOuterConeVolume(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getDopplerStrength")] + public static extern float IAudioSource_getDopplerStrength(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_getDopplerVelocity")] + public static extern IntPtr IAudioSource_getDopplerVelocity(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_registerEventHandler")] + public static extern void IAudioSource_registerEventHandler(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_unRegisterEventHandler")] + public static extern void IAudioSource_unRegisterEventHandler(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_unRegisterAllEventHandlers")] + public static extern void IAudioSource_unRegisterAllEventHandlers(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ICaptureEventHandler_onInit")] + public static extern void ICaptureEventHandler_onInit(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ICaptureEventHandler_onUpdate")] + public static extern void ICaptureEventHandler_onUpdate(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ICaptureEventHandler_onRelease")] + public static extern void ICaptureEventHandler_onRelease(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ICaptureEventHandler_onBeginCapture")] + public static extern void ICaptureEventHandler_onBeginCapture(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ICaptureEventHandler_onEndCapture")] + public static extern void ICaptureEventHandler_onEndCapture(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ICaptureEventHandler_onUserRequestBuffer")] + public static extern void ICaptureEventHandler_onUserRequestBuffer(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_ICaptureEventHandler")] + public static extern IntPtr new_ICaptureEventHandler(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_ICaptureEventHandler")] + public static extern void delete_ICaptureEventHandler(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ICaptureEventHandler_director_connect")] + public static extern void ICaptureEventHandler_director_connect(HandleRef jarg1, ICaptureEventHandler.SwigDelegateICaptureEventHandler_0 delegate0, ICaptureEventHandler.SwigDelegateICaptureEventHandler_1 delegate1, ICaptureEventHandler.SwigDelegateICaptureEventHandler_2 delegate2, ICaptureEventHandler.SwigDelegateICaptureEventHandler_3 delegate3, ICaptureEventHandler.SwigDelegateICaptureEventHandler_4 delegate4, ICaptureEventHandler.SwigDelegateICaptureEventHandler_5 delegate5); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_IDataSource")] + public static extern IntPtr new_IDataSource(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IDataSource")] + public static extern void delete_IDataSource(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IDataSource_isValid")] + public static extern bool IDataSource_isValid(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IDataSource_getCurrentPos")] + public static extern int IDataSource_getCurrentPos(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IDataSource_getSize")] + public static extern int IDataSource_getSize(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IDataSource_read")] + public static extern int IDataSource_read(HandleRef jarg1, HandleRef jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IDataSource_seek")] + public static extern bool IDataSource_seek(HandleRef jarg1, int jarg2, bool jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IDataSource_director_connect")] + public static extern void IDataSource_director_connect(HandleRef jarg1, IDataSource.SwigDelegateIDataSource_0 delegate0, IDataSource.SwigDelegateIDataSource_1 delegate1, IDataSource.SwigDelegateIDataSource_2 delegate2, IDataSource.SwigDelegateIDataSource_3 delegate3, IDataSource.SwigDelegateIDataSource_4 delegate4); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_IDataSourceFactory")] + public static extern IntPtr new_IDataSourceFactory(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IDataSourceFactory")] + public static extern void delete_IDataSourceFactory(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IDataSourceFactory_CreateDataSource")] + public static extern IntPtr IDataSourceFactory_CreateDataSource(HandleRef jarg1, string jarg2, bool jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IDataSourceFactory_director_connect")] + public static extern void IDataSourceFactory_director_connect(HandleRef jarg1, IDataSourceFactory.SwigDelegateIDataSourceFactory_0 delegate0); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IListener")] + public static extern void delete_IListener(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IListener_setPosition")] + public static extern void IListener_setPosition(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IListener_setDirection")] + public static extern void IListener_setDirection(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IListener_setUpVector")] + public static extern void IListener_setUpVector(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IListener_setVelocity")] + public static extern void IListener_setVelocity(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IListener_setMasterVolume")] + public static extern void IListener_setMasterVolume(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IListener_move")] + public static extern void IListener_move(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IListener_getPosition")] + public static extern IntPtr IListener_getPosition(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IListener_getDirection")] + public static extern IntPtr IListener_getDirection(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IListener_getUpVector")] + public static extern IntPtr IListener_getUpVector(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IListener_getVelocity")] + public static extern IntPtr IListener_getVelocity(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IListener_getMasterVolume")] + public static extern float IListener_getMasterVolume(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_ILogger")] + public static extern void delete_ILogger(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogger_logCritical")] + public static extern void ILogger_logCritical(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogger_logError")] + public static extern void ILogger_logError(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogger_logWarning")] + public static extern void ILogger_logWarning(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogger_logInfo")] + public static extern void ILogger_logInfo(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogger_logDebug")] + public static extern void ILogger_logDebug(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogger_getLogLevel")] + public static extern IntPtr ILogger_getLogLevel(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogger_setLogLevel")] + public static extern void ILogger_setLogLevel(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogger_registerLogReceiver")] + public static extern bool ILogger_registerLogReceiver(HandleRef jarg1, HandleRef jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogger_unRegisterLogReceiver")] + public static extern void ILogger_unRegisterLogReceiver(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogger_isLogReceiverRegistered")] + public static extern bool ILogger_isLogReceiverRegistered(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogger_getLogReceiver")] + public static extern IntPtr ILogger_getLogReceiver(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_LogLevelStrings_get")] + public static extern IntPtr LogLevelStrings_get(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_ILogReceiver")] + public static extern IntPtr new_ILogReceiver(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_ILogReceiver")] + public static extern void delete_ILogReceiver(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogReceiver_OnLogMessage")] + public static extern bool ILogReceiver_OnLogMessage(HandleRef jarg1, string jarg2, string jarg3, int jarg4, float jarg5); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ILogReceiver_director_connect")] + public static extern void ILogReceiver_director_connect(HandleRef jarg1, ILogReceiver.SwigDelegateILogReceiver_0 delegate0); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IManagerEventHandler_onInit")] + public static extern void IManagerEventHandler_onInit(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IManagerEventHandler_onUpdate")] + public static extern void IManagerEventHandler_onUpdate(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IManagerEventHandler_onRelease")] + public static extern void IManagerEventHandler_onRelease(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IManagerEventHandler_onSourceCreate")] + public static extern void IManagerEventHandler_onSourceCreate(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IManagerEventHandler_onDecoderRegister")] + public static extern void IManagerEventHandler_onDecoderRegister(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IManagerEventHandler_onDataSourceRegister")] + public static extern void IManagerEventHandler_onDataSourceRegister(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_IManagerEventHandler")] + public static extern IntPtr new_IManagerEventHandler(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IManagerEventHandler")] + public static extern void delete_IManagerEventHandler(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IManagerEventHandler_director_connect")] + public static extern void IManagerEventHandler_director_connect(HandleRef jarg1, IManagerEventHandler.SwigDelegateIManagerEventHandler_0 delegate0, IManagerEventHandler.SwigDelegateIManagerEventHandler_1 delegate1, IManagerEventHandler.SwigDelegateIManagerEventHandler_2 delegate2, IManagerEventHandler.SwigDelegateIManagerEventHandler_3 delegate3, IManagerEventHandler.SwigDelegateIManagerEventHandler_4 delegate4, IManagerEventHandler.SwigDelegateIManagerEventHandler_5 delegate5); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IMemoryProvider_Allocate")] + public static extern IntPtr IMemoryProvider_Allocate(HandleRef jarg1, uint jarg2, string jarg3, int jarg4, string jarg5); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IMemoryProvider_Free")] + public static extern void IMemoryProvider_Free(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IMemoryProvider_getMaxAllocationSize")] + public static extern uint IMemoryProvider_getMaxAllocationSize(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IMemoryProvider")] + public static extern void delete_IMemoryProvider(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ISourceEventHandler_onUpdate")] + public static extern void ISourceEventHandler_onUpdate(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ISourceEventHandler_onRelease")] + public static extern void ISourceEventHandler_onRelease(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ISourceEventHandler_onPlay")] + public static extern void ISourceEventHandler_onPlay(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ISourceEventHandler_onStop")] + public static extern void ISourceEventHandler_onStop(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ISourceEventHandler_onPause")] + public static extern void ISourceEventHandler_onPause(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_ISourceEventHandler")] + public static extern IntPtr new_ISourceEventHandler(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_ISourceEventHandler")] + public static extern void delete_ISourceEventHandler(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_ISourceEventHandler_director_connect")] + public static extern void ISourceEventHandler_director_connect(HandleRef jarg1, ISourceEventHandler.SwigDelegateISourceEventHandler_0 delegate0, ISourceEventHandler.SwigDelegateISourceEventHandler_1 delegate1, ISourceEventHandler.SwigDelegateISourceEventHandler_2 delegate2, ISourceEventHandler.SwigDelegateISourceEventHandler_3 delegate3, ISourceEventHandler.SwigDelegateISourceEventHandler_4 delegate4); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IThread_start")] + public static extern bool IThread_start(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IThread_join")] + public static extern void IThread_join(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IThread_shutdown")] + public static extern void IThread_shutdown(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IThread_isRunning")] + public static extern bool IThread_isRunning(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IThread")] + public static extern void delete_IThread(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IThreadWorker_run")] + public static extern void IThreadWorker_run(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IThreadWorker")] + public static extern void delete_IThreadWorker(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_createAudioManager__SWIG_0")] + public static extern IntPtr createAudioManager__SWIG_0(bool jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_createAudioManager__SWIG_1")] + public static extern IntPtr createAudioManager__SWIG_1(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_destroyAudioManager")] + public static extern void destroyAudioManager(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_createAudioCapture__SWIG_0")] + public static extern IntPtr createAudioCapture__SWIG_0(bool jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_createAudioCapture__SWIG_1")] + public static extern IntPtr createAudioCapture__SWIG_1(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_destroyAudioCapture")] + public static extern void destroyAudioCapture(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_getLogger")] + public static extern IntPtr getLogger(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_CAUDIO_VERSION_get")] + public static extern string CAUDIO_VERSION_get(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_CAUDIO_SOURCE_BUFFER_SIZE_get")] + public static extern int CAUDIO_SOURCE_BUFFER_SIZE_get(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_CAUDIO_SOURCE_NUM_BUFFERS_get")] + public static extern int CAUDIO_SOURCE_NUM_BUFFERS_get(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_CAUDIO_SOURCE_MAX_EFFECT_SLOTS_get")] + public static extern int CAUDIO_SOURCE_MAX_EFFECT_SLOTS_get(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_getMemoryProvider")] + public static extern IntPtr getMemoryProvider(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cAudioSleep")] + public static extern void cAudioSleep(uint jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_toWINSTR")] + public static extern string toWINSTR(string jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_toUTF8")] + public static extern string toUTF8(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_fromUTF8")] + public static extern IntPtr fromUTF8(string jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_Epsilon_get")] + public static extern float Epsilon_get(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_float_equals")] + public static extern bool float_equals(float jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_x_set")] + public static extern void cVector3_x_set(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_x_get")] + public static extern float cVector3_x_get(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_y_set")] + public static extern void cVector3_y_set(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_y_get")] + public static extern float cVector3_y_get(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_z_set")] + public static extern void cVector3_z_set(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_z_get")] + public static extern float cVector3_z_get(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_cVector3__SWIG_0")] + public static extern IntPtr new_cVector3__SWIG_0(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_cVector3__SWIG_1")] + public static extern IntPtr new_cVector3__SWIG_1(float jarg1, float jarg2, float jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_cVector3__SWIG_2")] + public static extern IntPtr new_cVector3__SWIG_2(float jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_cVector3__SWIG_3")] + public static extern IntPtr new_cVector3__SWIG_3(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_cVector3__SWIG_4")] + public static extern IntPtr new_cVector3__SWIG_4(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_Minus__SWIG_0")] + public static extern IntPtr cVector3_Minus__SWIG_0(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_Equal")] + public static extern IntPtr cVector3_Equal(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_Plus__SWIG_0")] + public static extern IntPtr cVector3_Plus__SWIG_0(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_PlusEqual__SWIG_0")] + public static extern IntPtr cVector3_PlusEqual__SWIG_0(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_Plus__SWIG_1")] + public static extern IntPtr cVector3_Plus__SWIG_1(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_PlusEqual__SWIG_1")] + public static extern IntPtr cVector3_PlusEqual__SWIG_1(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_Minus__SWIG_1")] + public static extern IntPtr cVector3_Minus__SWIG_1(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_MinusEqual__SWIG_0")] + public static extern IntPtr cVector3_MinusEqual__SWIG_0(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_Minus__SWIG_2")] + public static extern IntPtr cVector3_Minus__SWIG_2(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_MinusEqual__SWIG_1")] + public static extern IntPtr cVector3_MinusEqual__SWIG_1(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_Multiply__SWIG_0")] + public static extern IntPtr cVector3_Multiply__SWIG_0(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_MultiplyEqual__SWIG_0")] + public static extern IntPtr cVector3_MultiplyEqual__SWIG_0(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_Multiply__SWIG_1")] + public static extern IntPtr cVector3_Multiply__SWIG_1(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_MultiplyEqual__SWIG_1")] + public static extern IntPtr cVector3_MultiplyEqual__SWIG_1(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_Divide__SWIG_0")] + public static extern IntPtr cVector3_Divide__SWIG_0(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_DivideEqual__SWIG_0")] + public static extern IntPtr cVector3_DivideEqual__SWIG_0(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_Divide__SWIG_1")] + public static extern IntPtr cVector3_Divide__SWIG_1(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_DivideEqual__SWIG_1")] + public static extern IntPtr cVector3_DivideEqual__SWIG_1(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_LessThanEqual")] + public static extern bool cVector3_LessThanEqual(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_GreaterThanEqual")] + public static extern bool cVector3_GreaterThanEqual(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_LessThan")] + public static extern bool cVector3_LessThan(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_GreaterThan")] + public static extern bool cVector3_GreaterThan(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_EqualEqual")] + public static extern bool cVector3_EqualEqual(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_NotEqual")] + public static extern bool cVector3_NotEqual(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_length")] + public static extern float cVector3_length(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_normalize")] + public static extern void cVector3_normalize(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_dot")] + public static extern float cVector3_dot(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_cross")] + public static extern IntPtr cVector3_cross(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_set__SWIG_0")] + public static extern void cVector3_set__SWIG_0(HandleRef jarg1, float jarg2, float jarg3, float jarg4); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_set__SWIG_1")] + public static extern void cVector3_set__SWIG_1(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_set__SWIG_2")] + public static extern void cVector3_set__SWIG_2(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_cVector3_getAsArray")] + public static extern void cVector3_getAsArray(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_cVector3")] + public static extern void delete_cVector3(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IAudioCapture")] + public static extern void delete_IAudioCapture(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_initialize__SWIG_0")] + public static extern bool IAudioCapture_initialize__SWIG_0(HandleRef jarg1, string jarg2, uint jarg3, int jarg4, uint jarg5); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_initialize__SWIG_1")] + public static extern bool IAudioCapture_initialize__SWIG_1(HandleRef jarg1, string jarg2, uint jarg3, int jarg4); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_initialize__SWIG_2")] + public static extern bool IAudioCapture_initialize__SWIG_2(HandleRef jarg1, string jarg2, uint jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_initialize__SWIG_3")] + public static extern bool IAudioCapture_initialize__SWIG_3(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_initialize__SWIG_4")] + public static extern bool IAudioCapture_initialize__SWIG_4(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_isSupported")] + public static extern bool IAudioCapture_isSupported(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_isReady")] + public static extern bool IAudioCapture_isReady(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_updateCaptureBuffer__SWIG_0")] + public static extern void IAudioCapture_updateCaptureBuffer__SWIG_0(HandleRef jarg1, bool jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_updateCaptureBuffer__SWIG_1")] + public static extern void IAudioCapture_updateCaptureBuffer__SWIG_1(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_shutdown")] + public static extern void IAudioCapture_shutdown(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_isUpdateThreadRunning")] + public static extern bool IAudioCapture_isUpdateThreadRunning(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_getAvailableDeviceName")] + public static extern string IAudioCapture_getAvailableDeviceName(HandleRef jarg1, uint jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_getAvailableDeviceCount")] + public static extern uint IAudioCapture_getAvailableDeviceCount(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_getDefaultDeviceName")] + public static extern string IAudioCapture_getDefaultDeviceName(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_getDeviceName")] + public static extern string IAudioCapture_getDeviceName(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_getFrequency")] + public static extern uint IAudioCapture_getFrequency(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_getFormat")] + public static extern int IAudioCapture_getFormat(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_getInternalBufferSize")] + public static extern uint IAudioCapture_getInternalBufferSize(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_getSampleSize")] + public static extern uint IAudioCapture_getSampleSize(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_setDevice")] + public static extern bool IAudioCapture_setDevice(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_setFrequency")] + public static extern bool IAudioCapture_setFrequency(HandleRef jarg1, uint jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_setFormat")] + public static extern bool IAudioCapture_setFormat(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_setInternalBufferSize")] + public static extern bool IAudioCapture_setInternalBufferSize(HandleRef jarg1, uint jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_beginCapture")] + public static extern bool IAudioCapture_beginCapture(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_stopCapture")] + public static extern void IAudioCapture_stopCapture(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_getCapturedAudio")] + public static extern uint IAudioCapture_getCapturedAudio(HandleRef jarg1, HandleRef jarg2, uint jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_getCurrentCapturedAudioSize")] + public static extern uint IAudioCapture_getCurrentCapturedAudioSize(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_registerEventHandler")] + public static extern void IAudioCapture_registerEventHandler(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_unRegisterEventHandler")] + public static extern void IAudioCapture_unRegisterEventHandler(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioCapture_unRegisterAllEventHandlers")] + public static extern void IAudioCapture_unRegisterAllEventHandlers(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_IAudioDecoder")] + public static extern IntPtr new_IAudioDecoder(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IAudioDecoder")] + public static extern void delete_IAudioDecoder(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_getFormat")] + public static extern int IAudioDecoder_getFormat(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_getFrequency")] + public static extern int IAudioDecoder_getFrequency(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_isSeekingSupported")] + public static extern bool IAudioDecoder_isSeekingSupported(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_isValid")] + public static extern bool IAudioDecoder_isValid(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_readAudioData")] + public static extern int IAudioDecoder_readAudioData(HandleRef jarg1, HandleRef jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_setPosition")] + public static extern bool IAudioDecoder_setPosition(HandleRef jarg1, int jarg2, bool jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_seek")] + public static extern bool IAudioDecoder_seek(HandleRef jarg1, float jarg2, bool jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_getTotalTime")] + public static extern float IAudioDecoder_getTotalTime(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_getTotalSize")] + public static extern int IAudioDecoder_getTotalSize(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_getCompressedSize")] + public static extern int IAudioDecoder_getCompressedSize(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_getCurrentTime")] + public static extern float IAudioDecoder_getCurrentTime(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_getCurrentPosition")] + public static extern int IAudioDecoder_getCurrentPosition(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_getCurrentCompressedPosition")] + public static extern int IAudioDecoder_getCurrentCompressedPosition(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_director_connect")] + public static extern void IAudioDecoder_director_connect(HandleRef jarg1, IAudioDecoder.SwigDelegateIAudioDecoder_0 delegate0, IAudioDecoder.SwigDelegateIAudioDecoder_1 delegate1, IAudioDecoder.SwigDelegateIAudioDecoder_2 delegate2, IAudioDecoder.SwigDelegateIAudioDecoder_3 delegate3, IAudioDecoder.SwigDelegateIAudioDecoder_4 delegate4, IAudioDecoder.SwigDelegateIAudioDecoder_5 delegate5, IAudioDecoder.SwigDelegateIAudioDecoder_6 delegate6, IAudioDecoder.SwigDelegateIAudioDecoder_7 delegate7, IAudioDecoder.SwigDelegateIAudioDecoder_8 delegate8, IAudioDecoder.SwigDelegateIAudioDecoder_9 delegate9, IAudioDecoder.SwigDelegateIAudioDecoder_10 delegate10, IAudioDecoder.SwigDelegateIAudioDecoder_11 delegate11, IAudioDecoder.SwigDelegateIAudioDecoder_12 delegate12); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_IAudioDecoderFactory")] + public static extern IntPtr new_IAudioDecoderFactory(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IAudioDecoderFactory")] + public static extern void delete_IAudioDecoderFactory(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoderFactory_CreateAudioDecoder")] + public static extern IntPtr IAudioDecoderFactory_CreateAudioDecoder(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoderFactory_director_connect")] + public static extern void IAudioDecoderFactory_director_connect(HandleRef jarg1, IAudioDecoderFactory.SwigDelegateIAudioDecoderFactory_0 delegate0); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_Clear")] + public static extern void IntVector_Clear(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_Add")] + public static extern void IntVector_Add(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_size")] + public static extern uint IntVector_size(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_capacity")] + public static extern uint IntVector_capacity(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_reserve")] + public static extern void IntVector_reserve(HandleRef jarg1, uint jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_IntVector__SWIG_0")] + public static extern IntPtr new_IntVector__SWIG_0(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_IntVector__SWIG_1")] + public static extern IntPtr new_IntVector__SWIG_1(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_IntVector__SWIG_2")] + public static extern IntPtr new_IntVector__SWIG_2(int jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_getitemcopy")] + public static extern int IntVector_getitemcopy(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_getitem")] + public static extern int IntVector_getitem(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_setitem")] + public static extern void IntVector_setitem(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_AddRange")] + public static extern void IntVector_AddRange(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_GetRange")] + public static extern IntPtr IntVector_GetRange(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_Insert")] + public static extern void IntVector_Insert(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_InsertRange")] + public static extern void IntVector_InsertRange(HandleRef jarg1, int jarg2, HandleRef jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_RemoveAt")] + public static extern void IntVector_RemoveAt(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_RemoveRange")] + public static extern void IntVector_RemoveRange(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_Repeat")] + public static extern IntPtr IntVector_Repeat(int jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_Reverse__SWIG_0")] + public static extern void IntVector_Reverse__SWIG_0(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_Reverse__SWIG_1")] + public static extern void IntVector_Reverse__SWIG_1(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_SetRange")] + public static extern void IntVector_SetRange(HandleRef jarg1, int jarg2, HandleRef jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_Contains")] + public static extern bool IntVector_Contains(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_IndexOf")] + public static extern int IntVector_IndexOf(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_LastIndexOf")] + public static extern int IntVector_LastIndexOf(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IntVector_Remove")] + public static extern bool IntVector_Remove(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_IntVector")] + public static extern void delete_IntVector(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_Clear")] + public static extern void DoubleVector_Clear(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_Add")] + public static extern void DoubleVector_Add(HandleRef jarg1, double jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_size")] + public static extern uint DoubleVector_size(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_capacity")] + public static extern uint DoubleVector_capacity(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_reserve")] + public static extern void DoubleVector_reserve(HandleRef jarg1, uint jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_DoubleVector__SWIG_0")] + public static extern IntPtr new_DoubleVector__SWIG_0(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_DoubleVector__SWIG_1")] + public static extern IntPtr new_DoubleVector__SWIG_1(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_DoubleVector__SWIG_2")] + public static extern IntPtr new_DoubleVector__SWIG_2(int jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_getitemcopy")] + public static extern double DoubleVector_getitemcopy(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_getitem")] + public static extern double DoubleVector_getitem(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_setitem")] + public static extern void DoubleVector_setitem(HandleRef jarg1, int jarg2, double jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_AddRange")] + public static extern void DoubleVector_AddRange(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_GetRange")] + public static extern IntPtr DoubleVector_GetRange(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_Insert")] + public static extern void DoubleVector_Insert(HandleRef jarg1, int jarg2, double jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_InsertRange")] + public static extern void DoubleVector_InsertRange(HandleRef jarg1, int jarg2, HandleRef jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_RemoveAt")] + public static extern void DoubleVector_RemoveAt(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_RemoveRange")] + public static extern void DoubleVector_RemoveRange(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_Repeat")] + public static extern IntPtr DoubleVector_Repeat(double jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_Reverse__SWIG_0")] + public static extern void DoubleVector_Reverse__SWIG_0(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_Reverse__SWIG_1")] + public static extern void DoubleVector_Reverse__SWIG_1(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_SetRange")] + public static extern void DoubleVector_SetRange(HandleRef jarg1, int jarg2, HandleRef jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_Contains")] + public static extern bool DoubleVector_Contains(HandleRef jarg1, double jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_IndexOf")] + public static extern int DoubleVector_IndexOf(HandleRef jarg1, double jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_LastIndexOf")] + public static extern int DoubleVector_LastIndexOf(HandleRef jarg1, double jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_DoubleVector_Remove")] + public static extern bool DoubleVector_Remove(HandleRef jarg1, double jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_DoubleVector")] + public static extern void delete_DoubleVector(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_Clear")] + public static extern void StringVector_Clear(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_Add")] + public static extern void StringVector_Add(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_size")] + public static extern uint StringVector_size(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_capacity")] + public static extern uint StringVector_capacity(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_reserve")] + public static extern void StringVector_reserve(HandleRef jarg1, uint jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_StringVector__SWIG_0")] + public static extern IntPtr new_StringVector__SWIG_0(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_StringVector__SWIG_1")] + public static extern IntPtr new_StringVector__SWIG_1(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_StringVector__SWIG_2")] + public static extern IntPtr new_StringVector__SWIG_2(int jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_getitemcopy")] + public static extern string StringVector_getitemcopy(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_getitem")] + public static extern string StringVector_getitem(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_setitem")] + public static extern void StringVector_setitem(HandleRef jarg1, int jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_AddRange")] + public static extern void StringVector_AddRange(HandleRef jarg1, HandleRef jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_GetRange")] + public static extern IntPtr StringVector_GetRange(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_Insert")] + public static extern void StringVector_Insert(HandleRef jarg1, int jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_InsertRange")] + public static extern void StringVector_InsertRange(HandleRef jarg1, int jarg2, HandleRef jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_RemoveAt")] + public static extern void StringVector_RemoveAt(HandleRef jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_RemoveRange")] + public static extern void StringVector_RemoveRange(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_Repeat")] + public static extern IntPtr StringVector_Repeat(string jarg1, int jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_Reverse__SWIG_0")] + public static extern void StringVector_Reverse__SWIG_0(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_Reverse__SWIG_1")] + public static extern void StringVector_Reverse__SWIG_1(HandleRef jarg1, int jarg2, int jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_SetRange")] + public static extern void StringVector_SetRange(HandleRef jarg1, int jarg2, HandleRef jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_Contains")] + public static extern bool StringVector_Contains(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_IndexOf")] + public static extern int StringVector_IndexOf(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_LastIndexOf")] + public static extern int StringVector_LastIndexOf(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringVector_Remove")] + public static extern bool StringVector_Remove(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_StringVector")] + public static extern void delete_StringVector(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_StringMap__SWIG_0")] + public static extern IntPtr new_StringMap__SWIG_0(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_StringMap__SWIG_1")] + public static extern IntPtr new_StringMap__SWIG_1(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringMap_size")] + public static extern uint StringMap_size(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringMap_empty")] + public static extern bool StringMap_empty(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringMap_Clear")] + public static extern void StringMap_Clear(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringMap_getitem")] + public static extern string StringMap_getitem(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringMap_setitem")] + public static extern void StringMap_setitem(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringMap_ContainsKey")] + public static extern bool StringMap_ContainsKey(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringMap_Add")] + public static extern void StringMap_Add(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringMap_Remove")] + public static extern bool StringMap_Remove(HandleRef jarg1, string jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringMap_create_iterator_begin")] + public static extern IntPtr StringMap_create_iterator_begin(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringMap_get_next_key")] + public static extern string StringMap_get_next_key(HandleRef jarg1, IntPtr jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_StringMap_destroy_iterator")] + public static extern void StringMap_destroy_iterator(HandleRef jarg1, IntPtr jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_StringMap")] + public static extern void delete_StringMap(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_new_floatp")] + public static extern IntPtr new_floatp(); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_copy_floatp")] + public static extern IntPtr copy_floatp(float jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_delete_floatp")] + public static extern void delete_floatp(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_floatp_assign")] + public static extern void floatp_assign(HandleRef jarg1, float jarg2); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_floatp_value")] + public static extern float floatp_value(HandleRef jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioPlugin_SWIGUpcast")] + public static extern IntPtr IAudioPlugin_SWIGUpcast(IntPtr jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioSource_SWIGUpcast")] + public static extern IntPtr IAudioSource_SWIGUpcast(IntPtr jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IDataSource_SWIGUpcast")] + public static extern IntPtr IDataSource_SWIGUpcast(IntPtr jarg1); + + [DllImport("cAudioCSharpWrapper", EntryPoint="CSharp_IAudioDecoder_SWIGUpcast")] + public static extern IntPtr IAudioDecoder_SWIGUpcast(IntPtr jarg1); +} + +} diff --git a/cAudioCSharp/cVector3.cs b/cAudioCSharp/cVector3.cs new file mode 100644 index 0000000..36eb5ec --- /dev/null +++ b/cAudioCSharp/cVector3.cs @@ -0,0 +1,316 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace cAudio { + +using System; +using System.Runtime.InteropServices; + +public class cVector3 : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal cVector3(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(cVector3 obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~cVector3() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + cAudioCSharpWrapperPINVOKE.delete_cVector3(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + + public static bool operator>(cVector3 lhs, cVector3 rhs) + { + return lhs.GreaterThan(rhs); + } + + public static bool operator>=(cVector3 lhs, cVector3 rhs) + { + return lhs.GreaterThan(rhs) || lhs.EqualEqual(rhs); + } + + public static bool operator<(cVector3 lhs, cVector3 rhs) + { + return lhs.LessThan(rhs); + } + + public static bool operator<=(cVector3 lhs, cVector3 rhs) + { + return lhs.LessThan(rhs) || lhs.EqualEqual(rhs); + } + + public static cVector3 operator+(cVector3 lhs, cVector3 rhs) + { + return lhs.Plus(rhs); + } + + public static cVector3 operator*(cVector3 lhs, cVector3 rhs) + { + return lhs.Multiply(rhs); + } + + public static cVector3 operator*(cVector3 lhs, float rhs) + { + return lhs.Multiply(rhs); + } + + public static cVector3 operator/(cVector3 lhs, cVector3 rhs) + { + return lhs.Divide(rhs); + } + + public static cVector3 operator/(cVector3 lhs, float rhs) + { + return lhs.Divide(rhs); + } + + public static cVector3 operator-(cVector3 lhs, cVector3 rhs) + { + return lhs.Minus(rhs); + } + + public float x { + set { + cAudioCSharpWrapperPINVOKE.cVector3_x_set(swigCPtr, value); + } + get { + float ret = cAudioCSharpWrapperPINVOKE.cVector3_x_get(swigCPtr); + return ret; + } + } + + public float y { + set { + cAudioCSharpWrapperPINVOKE.cVector3_y_set(swigCPtr, value); + } + get { + float ret = cAudioCSharpWrapperPINVOKE.cVector3_y_get(swigCPtr); + return ret; + } + } + + public float z { + set { + cAudioCSharpWrapperPINVOKE.cVector3_z_set(swigCPtr, value); + } + get { + float ret = cAudioCSharpWrapperPINVOKE.cVector3_z_get(swigCPtr); + return ret; + } + } + + public cVector3() : this(cAudioCSharpWrapperPINVOKE.new_cVector3__SWIG_0(), true) { + } + + public cVector3(float nx, float ny, float nz) : this(cAudioCSharpWrapperPINVOKE.new_cVector3__SWIG_1(nx, ny, nz), true) { + } + + public cVector3(float n) : this(cAudioCSharpWrapperPINVOKE.new_cVector3__SWIG_2(n), true) { + } + + public cVector3(cVector3 other) : this(cAudioCSharpWrapperPINVOKE.new_cVector3__SWIG_3(cVector3.getCPtr(other)), true) { + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public cVector3(SWIGTYPE_p_float vector) : this(cAudioCSharpWrapperPINVOKE.new_cVector3__SWIG_4(SWIGTYPE_p_float.getCPtr(vector)), true) { + } + + public cVector3 Minus() { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_Minus__SWIG_0(swigCPtr), true); + return ret; + } + + public cVector3 Equal(cVector3 other) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_Equal(swigCPtr, cVector3.getCPtr(other)), false); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public cVector3 Plus(cVector3 other) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_Plus__SWIG_0(swigCPtr, cVector3.getCPtr(other)), true); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public cVector3 PlusEqual(cVector3 other) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_PlusEqual__SWIG_0(swigCPtr, cVector3.getCPtr(other)), false); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public cVector3 Plus(float val) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_Plus__SWIG_1(swigCPtr, val), true); + return ret; + } + + public cVector3 PlusEqual(float val) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_PlusEqual__SWIG_1(swigCPtr, val), false); + return ret; + } + + public cVector3 Minus(cVector3 other) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_Minus__SWIG_1(swigCPtr, cVector3.getCPtr(other)), true); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public cVector3 MinusEqual(cVector3 other) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_MinusEqual__SWIG_0(swigCPtr, cVector3.getCPtr(other)), false); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public cVector3 Minus(float val) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_Minus__SWIG_2(swigCPtr, val), true); + return ret; + } + + public cVector3 MinusEqual(float val) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_MinusEqual__SWIG_1(swigCPtr, val), false); + return ret; + } + + public cVector3 Multiply(cVector3 other) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_Multiply__SWIG_0(swigCPtr, cVector3.getCPtr(other)), true); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public cVector3 MultiplyEqual(cVector3 other) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_MultiplyEqual__SWIG_0(swigCPtr, cVector3.getCPtr(other)), false); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public cVector3 Multiply(float v) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_Multiply__SWIG_1(swigCPtr, v), true); + return ret; + } + + public cVector3 MultiplyEqual(float v) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_MultiplyEqual__SWIG_1(swigCPtr, v), false); + return ret; + } + + public cVector3 Divide(cVector3 other) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_Divide__SWIG_0(swigCPtr, cVector3.getCPtr(other)), true); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public cVector3 DivideEqual(cVector3 other) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_DivideEqual__SWIG_0(swigCPtr, cVector3.getCPtr(other)), false); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public cVector3 Divide(float v) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_Divide__SWIG_1(swigCPtr, v), true); + return ret; + } + + public cVector3 DivideEqual(float v) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_DivideEqual__SWIG_1(swigCPtr, v), false); + return ret; + } + + public bool LessThanEqual(cVector3 other) { + bool ret = cAudioCSharpWrapperPINVOKE.cVector3_LessThanEqual(swigCPtr, cVector3.getCPtr(other)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool GreaterThanEqual(cVector3 other) { + bool ret = cAudioCSharpWrapperPINVOKE.cVector3_GreaterThanEqual(swigCPtr, cVector3.getCPtr(other)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool LessThan(cVector3 other) { + bool ret = cAudioCSharpWrapperPINVOKE.cVector3_LessThan(swigCPtr, cVector3.getCPtr(other)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool GreaterThan(cVector3 other) { + bool ret = cAudioCSharpWrapperPINVOKE.cVector3_GreaterThan(swigCPtr, cVector3.getCPtr(other)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool EqualEqual(cVector3 other) { + bool ret = cAudioCSharpWrapperPINVOKE.cVector3_EqualEqual(swigCPtr, cVector3.getCPtr(other)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool NotEqual(cVector3 other) { + bool ret = cAudioCSharpWrapperPINVOKE.cVector3_NotEqual(swigCPtr, cVector3.getCPtr(other)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public float length() { + float ret = cAudioCSharpWrapperPINVOKE.cVector3_length(swigCPtr); + return ret; + } + + public void normalize() { + cAudioCSharpWrapperPINVOKE.cVector3_normalize(swigCPtr); + } + + public float dot(cVector3 other) { + float ret = cAudioCSharpWrapperPINVOKE.cVector3_dot(swigCPtr, cVector3.getCPtr(other)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public cVector3 cross(cVector3 other) { + cVector3 ret = new cVector3(cAudioCSharpWrapperPINVOKE.cVector3_cross(swigCPtr, cVector3.getCPtr(other)), true); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void set(float nx, float ny, float nz) { + cAudioCSharpWrapperPINVOKE.cVector3_set__SWIG_0(swigCPtr, nx, ny, nz); + } + + public void set(float n) { + cAudioCSharpWrapperPINVOKE.cVector3_set__SWIG_1(swigCPtr, n); + } + + public void set(cVector3 other) { + cAudioCSharpWrapperPINVOKE.cVector3_set__SWIG_2(swigCPtr, cVector3.getCPtr(other)); + if (cAudioCSharpWrapperPINVOKE.SWIGPendingException.Pending) throw cAudioCSharpWrapperPINVOKE.SWIGPendingException.Retrieve(); + } + + public void getAsArray(SWIGTYPE_p_float output) { + cAudioCSharpWrapperPINVOKE.cVector3_getAsArray(swigCPtr, SWIGTYPE_p_float.getCPtr(output)); + } + +} + +} diff --git a/cAudioCSharpWrapper/CMakeLists.txt b/cAudioCSharpWrapper/CMakeLists.txt new file mode 100644 index 0000000..1bb5158 --- /dev/null +++ b/cAudioCSharpWrapper/CMakeLists.txt @@ -0,0 +1,12 @@ +PROJECT(cAudioCSharpWrapper) +set(CMAKE_DEBUG_POSTFIX) + +include_directories (include ${CAUDIO_INCLUDE_DIR}) + +include (cAudioCSharpWrapper_src_files.cmake) + +add_library(cAudioCSharpWrapper SHARED ${file_root}) +target_link_libraries(cAudioCSharpWrapper cAudio) +add_dependencies(cAudioCSharpWrapper cAudio) + +install_all_targets(cAudioCSharpWrapper) diff --git a/cAudioCSharpWrapper/GenerateCSharpBinding.bat b/cAudioCSharpWrapper/GenerateCSharpBinding.bat new file mode 100644 index 0000000..3de80c7 --- /dev/null +++ b/cAudioCSharpWrapper/GenerateCSharpBinding.bat @@ -0,0 +1,3 @@ +echo Invoking SWIG... +del "..\cAudioCSharp\*.cs" +%SWIG_PATH%\swig.exe -outdir "..\cAudioCSharp" -namespace cAudio -c++ -csharp "%CD%/src/cAudioWrapped.i" diff --git a/cAudioCSharpWrapper/cAudioCSharpWrapper_src_files.cmake b/cAudioCSharpWrapper/cAudioCSharpWrapper_src_files.cmake new file mode 100644 index 0000000..b44543d --- /dev/null +++ b/cAudioCSharpWrapper/cAudioCSharpWrapper_src_files.cmake @@ -0,0 +1,15 @@ +set (file_root_source_files + src/cAudioWrapped_wrap.cxx +) +set (file_root_header_files + src/cAudioWrapped_wrap.h +) + +source_group("Source Files" FILES ${file_root_source_files}) +source_group("Header Files" FILES ${file_root_header_files}) + + +set (file_root + ${file_root_source_files} + ${file_root_header_files} +) diff --git a/cAudioCSharpWrapper/src/cAudioWrapped.i b/cAudioCSharpWrapper/src/cAudioWrapped.i new file mode 100644 index 0000000..34eeb06 --- /dev/null +++ b/cAudioCSharpWrapper/src/cAudioWrapped.i @@ -0,0 +1,181 @@ +%module(directors="1") cAudioCSharpWrapper +%include "std_string.i" +%include "std_vector.i" +%include "std_map.i" +%include "cpointer.i" + +#define CAUDIO_API + +%{ +#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 "cAudioString.h" +#include "cSTLAllocator.h" +#include "cVector3.h" +#include "IAudioCapture.h" +#include "IAudioDecoder.h" +#include "IAudioDecoderFactory.h" +%} + +#if !defined(SWIGLUA) && !defined(SWIGR) +%rename(Equal) operator =; +%rename(PlusEqual) operator +=; +%rename(MinusEqual) operator -=; +%rename(MultiplyEqual) operator *=; +%rename(DivideEqual) operator /=; +%rename(PercentEqual) operator %=; +%rename(Plus) operator +; +%rename(Minus) operator -; +%rename(Multiply) operator *; +%rename(Divide) operator /; +%rename(Percent) operator %; +%rename(Not) operator !; +%rename(IndexIntoConst) operator[](size_t) const; +%rename(IndexIntoConstConst) operator [] ( const size_t ) const; +%rename(IndexInto) operator[](size_t); +%rename(Functor) operator (); +%rename(EqualEqual) operator ==; +%rename(NotEqual) operator !=; +%rename(LessThan) operator <; +%rename(LessThanEqual) operator <=; +%rename(GreaterThan) operator >; +%rename(GreaterThanEqual) operator >=; +%rename(And) operator &&; +%rename(Or) operator ||; +%rename(PlusPlusPrefix) operator++(); +%rename(PlusPlusPostfix) operator++(int); +%rename(MinusMinusPrefix) operator--(); +%rename(MinusMinusPostfix) operator--(int); +%rename(WriteIntoOp) operator <<; +%rename(WriteToOp) operator >>; +%rename(ToRadian) operator Radian() const; +%rename(ToDegree) operator Degree() const; + +#endif + + + +%typemap(cscode) cAudio::cVector3 %{ + + public static bool operator>(cVector3 lhs, cVector3 rhs) + { + return lhs.GreaterThan(rhs); + } + + public static bool operator>=(cVector3 lhs, cVector3 rhs) + { + return lhs.GreaterThan(rhs) || lhs.EqualEqual(rhs); + } + + public static bool operator<(cVector3 lhs, cVector3 rhs) + { + return lhs.LessThan(rhs); + } + + public static bool operator<=(cVector3 lhs, cVector3 rhs) + { + return lhs.LessThan(rhs) || lhs.EqualEqual(rhs); + } + + public static cVector3 operator+(cVector3 lhs, cVector3 rhs) + { + return lhs.Plus(rhs); + } + + public static cVector3 operator*(cVector3 lhs, cVector3 rhs) + { + return lhs.Multiply(rhs); + } + + public static cVector3 operator*(cVector3 lhs, float rhs) + { + return lhs.Multiply(rhs); + } + + public static cVector3 operator/(cVector3 lhs, cVector3 rhs) + { + return lhs.Divide(rhs); + } + + public static cVector3 operator/(cVector3 lhs, float rhs) + { + return lhs.Divide(rhs); + } + + public static cVector3 operator-(cVector3 lhs, cVector3 rhs) + { + return lhs.Minus(rhs); + } +%} + +%feature("director") cAudio::ILogReceiver; +%feature("director") cAudio::ISourceEventHandler; +%feature("director") cAudio::ICaptureEventHandler; +%feature("director") cAudio::IDataSource; +%feature("director") cAudio::IDataSourceFactory; +%feature("director") cAudio::IManagerEventHandler; +%feature("director") cAudio::IAudioDecoderFactory; +%feature("director") cAudio::IAudioDecoder; + +%include "..\cAudio\include\IRefCounted.h" +%include "..\cAudio\include\IAudioEffects.h" +%include "..\cAudio\include\IAudioManager.h" +%include "..\cAudio\include\IAudioPlugin.h" +%include "..\cAudio\include\IAudioSource.h" +%include "..\cAudio\include\ICaptureEventHandler.h" +%include "..\cAudio\include\IDataSource.h" +%include "..\cAudio\include\IDataSourceFactory.h" +%include "..\cAudio\include\IEffect.h" +%include "..\cAudio\include\IEffectParameters.h" +%include "..\cAudio\include\IFilter.h" +%include "..\cAudio\include\IListener.h" +%include "..\cAudio\include\ILogger.h" +%include "..\cAudio\include\ILogReceiver.h" +%include "..\cAudio\include\IManagerEventHandler.h" +%include "..\cAudio\include\IMemoryProvider.h" +%include "..\cAudio\include\IPluginManager.h" +%include "..\cAudio\include\ISourceEventHandler.h" +%include "..\cAudio\include\IThread.h" +%include "..\cAudio\include\cAudio.h" +%include "..\cAudio\include\cAudioDefines.h" +%include "..\cAudio\include\cAudioMemory.h" +%include "..\cAudio\include\cAudioPlatform.h" +%include "..\cAudio\include\cAudioSleep.h" +%include "..\cAudio\include\cAudioString.h" +%include "..\cAudio\include\cVector3.h" +%include "..\cAudio\include\EAudioFormats.h" +%include "..\cAudio\include\IAudioCapture.h" +%include "..\cAudio\include\IAudioDecoder.h" +%include "..\cAudio\include\IAudioDecoderFactory.h" + +namespace std { + %template(IntVector) vector; + %template(DoubleVector) vector; + %template(StringVector) vector; + %template(StringMap) map; +}; + +%pointer_functions(float, floatp); diff --git a/cAudioCSharpWrapper/src/cAudioWrapped_wrap.cxx b/cAudioCSharpWrapper/src/cAudioWrapped_wrap.cxx new file mode 100644 index 0000000..dbdcbbc --- /dev/null +++ b/cAudioCSharpWrapper/src/cAudioWrapped_wrap.cxx @@ -0,0 +1,6625 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * 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 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& rhs); + SwigValueWrapper(const SwigValueWrapper& 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 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 +#include +#include + + +/* 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 +#endif +#include + +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 + + +#include + + +#include +#include +#include + + +#include +#include +#include + + +#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 "cAudioString.h" +#include "cSTLAllocator.h" +#include "cVector3.h" +#include "IAudioCapture.h" +#include "IAudioDecoder.h" +#include "IAudioDecoderFactory.h" + +using namespace cAudio; + +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 *self) { + if (self) delete self; +} + +static void floatp_assign(float *self, float value) { + *self = value; +} + +static float floatp_value(float *self) { + return *self; +} + + + +/* --------------------------------------------------- + * C++ director class methods + * --------------------------------------------------- */ + +#include "cAudioWrapped_wrap.h" + +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_IDataSource::SwigDirector_IDataSource() : cAudio::IDataSource(), Swig::Director() { + swig_init_callbacks(); +} + +SwigDirector_IDataSource::~SwigDirector_IDataSource() { + +} + + +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 callbackisValid, SWIG_Callback1_t callbackgetCurrentPos, SWIG_Callback2_t callbackgetSize, SWIG_Callback3_t callbackread, SWIG_Callback4_t callbackseek) { + swig_callbackisValid = callbackisValid; + swig_callbackgetCurrentPos = callbackgetCurrentPos; + swig_callbackgetSize = callbackgetSize; + swig_callbackread = callbackread; + swig_callbackseek = callbackseek; +} + +void SwigDirector_IDataSource::swig_init_callbacks() { + 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_IAudioDecoder::SwigDirector_IAudioDecoder(cAudio::IDataSource *stream) : cAudio::IAudioDecoder(stream), Swig::Director() { + swig_init_callbacks(); +} + +SwigDirector_IAudioDecoder::~SwigDirector_IAudioDecoder() { + +} + + +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; +} + +void SwigDirector_IAudioDecoder::swig_connect_director(SWIG_Callback0_t callbackgetFormat, SWIG_Callback1_t callbackgetFrequency, SWIG_Callback2_t callbackisSeekingSupported, SWIG_Callback3_t callbackisValid, SWIG_Callback4_t callbackreadAudioData, SWIG_Callback5_t callbacksetPosition, SWIG_Callback6_t callbackseek, SWIG_Callback7_t callbackgetTotalTime, SWIG_Callback8_t callbackgetTotalSize, SWIG_Callback9_t callbackgetCompressedSize, SWIG_Callback10_t callbackgetCurrentTime, SWIG_Callback11_t callbackgetCurrentPosition, SWIG_Callback12_t callbackgetCurrentCompressedPosition) { + 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; +} + +void SwigDirector_IAudioDecoder::swig_init_callbacks() { + 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; +} + +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 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_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 char * SWIGSTDCALL CSharp_IAudioManager_getAvailableDeviceName(void * jarg1, unsigned int jarg2) { + char * jresult ; + cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ; + unsigned int arg2 ; + char *result = 0 ; + + arg1 = (cAudio::IAudioManager *)jarg1; + arg2 = (unsigned int)jarg2; + result = (char *)(arg1)->getAvailableDeviceName(arg2); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioManager_getAvailableDeviceCount(void * jarg1) { + unsigned int jresult ; + cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ; + unsigned int result; + + arg1 = (cAudio::IAudioManager *)jarg1; + result = (unsigned int)(arg1)->getAvailableDeviceCount(); + jresult = result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_IAudioManager_getDefaultDeviceName(void * jarg1) { + char * jresult ; + cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ; + char *result = 0 ; + + arg1 = (cAudio::IAudioManager *)jarg1; + result = (char *)(arg1)->getDefaultDeviceName(); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +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, void * jarg6) { + void * jresult ; + cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + size_t arg4 ; + unsigned int arg5 ; + AudioFormats arg6 ; + AudioFormats *argp6 ; + cAudio::IAudioSource *result = 0 ; + + arg1 = (cAudio::IAudioManager *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char *)jarg3; + arg4 = (size_t)jarg4; + arg5 = (unsigned int)jarg5; + argp6 = (AudioFormats *)jarg6; + if (!argp6) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null AudioFormats", 0); + return 0; + } + arg6 = *argp6; + result = (cAudio::IAudioSource *)(arg1)->createFromRaw((char const *)arg2,(char const *)arg3,arg4,arg5,arg6); + 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 ; + IDataSourceFactory *arg2 = (IDataSourceFactory *) 0 ; + char *arg3 = (char *) 0 ; + int arg4 ; + bool result; + + arg1 = (cAudio::IAudioManager *)jarg1; + arg2 = (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 ; + IDataSourceFactory *result = 0 ; + + arg1 = (cAudio::IAudioManager *)jarg1; + arg2 = (char *)jarg2; + result = (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 ; + IManagerEventHandler *arg2 = (IManagerEventHandler *) 0 ; + + arg1 = (cAudio::IAudioManager *)jarg1; + arg2 = (IManagerEventHandler *)jarg2; + (arg1)->registerEventHandler(arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_unRegisterEventHandler(void * jarg1, void * jarg2) { + cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ; + IManagerEventHandler *arg2 = (IManagerEventHandler *) 0 ; + + arg1 = (cAudio::IAudioManager *)jarg1; + arg2 = (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 ; + IListener *result = 0 ; + + arg1 = (cAudio::IAudioManager *)jarg1; + result = (IListener *)(arg1)->getListener(); + jresult = (void *)result; + return jresult; +} + + +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 ; + ILogger *arg2 = (ILogger *) 0 ; + bool result; + + arg1 = (cAudio::IAudioPlugin *)jarg1; + arg2 = (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 ; + IAudioCapture *arg2 = (IAudioCapture *) 0 ; + + arg1 = (cAudio::IAudioPlugin *)jarg1; + arg2 = (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 ; + IAudioCapture *arg2 = (IAudioCapture *) 0 ; + + arg1 = (cAudio::IAudioPlugin *)jarg1; + arg2 = (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 ; + cVector3 *arg2 = 0 ; + float *arg3 = 0 ; + bool *arg4 = 0 ; + float temp3 ; + bool temp4 ; + bool result; + + arg1 = (cAudio::IAudioSource *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return 0; + } + temp3 = (float)jarg3; + arg3 = &temp3; + temp4 = jarg4 ? true : false; + arg4 = &temp4; + result = (bool)(arg1)->play3d((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 ; + cVector3 *arg2 = 0 ; + float *arg3 = 0 ; + float temp3 ; + bool result; + + arg1 = (cAudio::IAudioSource *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return 0; + } + temp3 = (float)jarg3; + arg3 = &temp3; + result = (bool)(arg1)->play3d((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 ; + cVector3 *arg2 = 0 ; + bool result; + + arg1 = (cAudio::IAudioSource *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return 0; + } + result = (bool)(arg1)->play3d((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 void SWIGSTDCALL CSharp_IAudioSource_release(void * jarg1) { + cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ; + + arg1 = (cAudio::IAudioSource *)jarg1; + (arg1)->release(); +} + + +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 ; + cVector3 *arg2 = 0 ; + + arg1 = (cAudio::IAudioSource *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return ; + } + (arg1)->setPosition((cVector3 const &)*arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setVelocity(void * jarg1, void * jarg2) { + cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ; + cVector3 *arg2 = 0 ; + + arg1 = (cAudio::IAudioSource *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return ; + } + (arg1)->setVelocity((cVector3 const &)*arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setDirection(void * jarg1, void * jarg2) { + cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ; + cVector3 *arg2 = 0 ; + + arg1 = (cAudio::IAudioSource *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return ; + } + (arg1)->setDirection((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_setMaxDistance(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)->setMaxDistance((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 ; + cVector3 *arg2 = 0 ; + + arg1 = (cAudio::IAudioSource *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return ; + } + (arg1)->setDopplerVelocity((cVector3 const &)*arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_move(void * jarg1, void * jarg2) { + cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ; + cVector3 *arg2 = 0 ; + + arg1 = (cAudio::IAudioSource *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return ; + } + (arg1)->move((cVector3 const &)*arg2); +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioSource_getPosition(void * jarg1) { + void * jresult ; + cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ; + cVector3 result; + + arg1 = (cAudio::IAudioSource *)jarg1; + result = ((cAudio::IAudioSource const *)arg1)->getPosition(); + jresult = new cVector3((const cVector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioSource_getVelocity(void * jarg1) { + void * jresult ; + cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ; + cVector3 result; + + arg1 = (cAudio::IAudioSource *)jarg1; + result = ((cAudio::IAudioSource const *)arg1)->getVelocity(); + jresult = new cVector3((const cVector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioSource_getDirection(void * jarg1) { + void * jresult ; + cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ; + cVector3 result; + + arg1 = (cAudio::IAudioSource *)jarg1; + result = ((cAudio::IAudioSource const *)arg1)->getDirection(); + jresult = new cVector3((const 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 ; + cVector3 result; + + arg1 = (cAudio::IAudioSource *)jarg1; + result = ((cAudio::IAudioSource const *)arg1)->getDopplerVelocity(); + jresult = new cVector3((const cVector3 &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_registerEventHandler(void * jarg1, void * jarg2) { + cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ; + ISourceEventHandler *arg2 = (ISourceEventHandler *) 0 ; + + arg1 = (cAudio::IAudioSource *)jarg1; + arg2 = (ISourceEventHandler *)jarg2; + (arg1)->registerEventHandler(arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_unRegisterEventHandler(void * jarg1, void * jarg2) { + cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ; + ISourceEventHandler *arg2 = (ISourceEventHandler *) 0 ; + + arg1 = (cAudio::IAudioSource *)jarg1; + arg2 = (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_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(obj); + if (director) { + director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5); + } +} + + +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) { + cAudio::IDataSource *obj = (cAudio::IDataSource *)objarg; + SwigDirector_IDataSource *director = dynamic_cast(obj); + if (director) { + director->swig_connect_director(callback0, callback1, callback2, callback3, callback4); + } +} + + +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(obj); + if (director) { + director->swig_connect_director(callback0); + } +} + + +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 ; + cVector3 *arg2 = 0 ; + + arg1 = (cAudio::IListener *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return ; + } + (arg1)->setPosition((cVector3 const &)*arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_IListener_setDirection(void * jarg1, void * jarg2) { + cAudio::IListener *arg1 = (cAudio::IListener *) 0 ; + cVector3 *arg2 = 0 ; + + arg1 = (cAudio::IListener *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return ; + } + (arg1)->setDirection((cVector3 const &)*arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_IListener_setUpVector(void * jarg1, void * jarg2) { + cAudio::IListener *arg1 = (cAudio::IListener *) 0 ; + cVector3 *arg2 = 0 ; + + arg1 = (cAudio::IListener *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return ; + } + (arg1)->setUpVector((cVector3 const &)*arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_IListener_setVelocity(void * jarg1, void * jarg2) { + cAudio::IListener *arg1 = (cAudio::IListener *) 0 ; + cVector3 *arg2 = 0 ; + + arg1 = (cAudio::IListener *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return ; + } + (arg1)->setVelocity((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 ; + cVector3 *arg2 = 0 ; + + arg1 = (cAudio::IListener *)jarg1; + arg2 = (cVector3 *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cVector3 const & type is null", 0); + return ; + } + (arg1)->move((cVector3 const &)*arg2); +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_IListener_getPosition(void * jarg1) { + void * jresult ; + cAudio::IListener *arg1 = (cAudio::IListener *) 0 ; + cVector3 result; + + arg1 = (cAudio::IListener *)jarg1; + result = ((cAudio::IListener const *)arg1)->getPosition(); + jresult = new cVector3((const cVector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_IListener_getDirection(void * jarg1) { + void * jresult ; + cAudio::IListener *arg1 = (cAudio::IListener *) 0 ; + cVector3 result; + + arg1 = (cAudio::IListener *)jarg1; + result = ((cAudio::IListener const *)arg1)->getDirection(); + jresult = new cVector3((const cVector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_IListener_getUpVector(void * jarg1) { + void * jresult ; + cAudio::IListener *arg1 = (cAudio::IListener *) 0 ; + cVector3 result; + + arg1 = (cAudio::IListener *)jarg1; + result = ((cAudio::IListener const *)arg1)->getUpVector(); + jresult = new cVector3((const cVector3 &)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_IListener_getVelocity(void * jarg1) { + void * jresult ; + cAudio::IListener *arg1 = (cAudio::IListener *) 0 ; + cVector3 result; + + arg1 = (cAudio::IListener *)jarg1; + result = ((cAudio::IListener const *)arg1)->getVelocity(); + jresult = new cVector3((const 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_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 void * SWIGSTDCALL CSharp_ILogger_getLogLevel(void * jarg1) { + void * jresult ; + cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ; + LogLevel *result = 0 ; + + arg1 = (cAudio::ILogger *)jarg1; + result = (LogLevel *) &((cAudio::ILogger const *)arg1)->getLogLevel(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_ILogger_setLogLevel(void * jarg1, void * jarg2) { + cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ; + LogLevel *arg2 = 0 ; + + arg1 = (cAudio::ILogger *)jarg1; + arg2 = (LogLevel *)jarg2; + if (!arg2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LogLevel const & type is null", 0); + return ; + } + (arg1)->setLogLevel((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 ; + ILogReceiver *arg2 = (ILogReceiver *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + + arg1 = (cAudio::ILogger *)jarg1; + arg2 = (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 ; + ILogReceiver *result = 0 ; + + arg1 = (cAudio::ILogger *)jarg1; + arg2 = (char *)jarg2; + result = (ILogReceiver *)(arg1)->getLogReceiver((char const *)arg2); + jresult = (void *)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(obj); + if (director) { + director->swig_connect_director(callback0); + } +} + + +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(obj); + if (director) { + director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5); + } +} + + +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 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(obj); + if (director) { + director->swig_connect_director(callback0, callback1, callback2, callback3, callback4); + } +} + + +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 ; + IAudioCapture *result = 0 ; + + arg1 = jarg1 ? true : false; + result = (IAudioCapture *)cAudio::createAudioCapture(arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_createAudioCapture__SWIG_1() { + void * jresult ; + IAudioCapture *result = 0 ; + + result = (IAudioCapture *)cAudio::createAudioCapture(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_destroyAudioCapture(void * jarg1) { + IAudioCapture *arg1 = (IAudioCapture *) 0 ; + + arg1 = (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 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 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(void * jarg1) { + char * jresult ; + cAudio::cAudioString *arg1 = 0 ; + char *result = 0 ; + + arg1 = (cAudio::cAudioString *)jarg1; + if (!arg1) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cAudioString const & type is null", 0); + return 0; + } + result = (char *)cAudio::toUTF8(*arg1); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_fromUTF8(char * jarg1) { + void * jresult ; + char *arg1 = (char *) 0 ; + cAudio::cAudioString result; + + arg1 = (char *)jarg1; + result = cAudio::fromUTF8((char const *)arg1); + jresult = new cAudio::cAudioString((const cAudio::cAudioString &)result); + return jresult; +} + + +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_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_isSupported(void * jarg1) { + unsigned int jresult ; + cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ; + bool result; + + arg1 = (cAudio::IAudioCapture *)jarg1; + result = (bool)(arg1)->isSupported(); + 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_getAvailableDeviceName(void * jarg1, unsigned int jarg2) { + char * jresult ; + cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ; + unsigned int arg2 ; + char *result = 0 ; + + arg1 = (cAudio::IAudioCapture *)jarg1; + arg2 = (unsigned int)jarg2; + result = (char *)(arg1)->getAvailableDeviceName(arg2); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_getAvailableDeviceCount(void * jarg1) { + unsigned int jresult ; + cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ; + unsigned int result; + + arg1 = (cAudio::IAudioCapture *)jarg1; + result = (unsigned int)(arg1)->getAvailableDeviceCount(); + jresult = result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_IAudioCapture_getDefaultDeviceName(void * jarg1) { + char * jresult ; + cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ; + char *result = 0 ; + + arg1 = (cAudio::IAudioCapture *)jarg1; + result = (char *)(arg1)->getDefaultDeviceName(); + jresult = SWIG_csharp_string_callback((const char *)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 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_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 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) { + cAudio::IAudioDecoder *obj = (cAudio::IAudioDecoder *)objarg; + SwigDirector_IAudioDecoder *director = dynamic_cast(obj); + if (director) { + director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12); + } +} + + +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(obj); + if (director) { + director->swig_connect_director(callback0); + } +} + + +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::string 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::string arg2_str(jarg2); + arg2 = &arg2_str; + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string 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::string 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::string arg2_str(jarg2); + arg2 = &arg2_str; + if (!jarg3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0); + return ; + } + std::string 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::string 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_IAudioPlugin_SWIGUpcast(cAudio::IAudioPlugin *jarg1) { + return (cAudio::IRefCounted *)jarg1; +} + +SWIGEXPORT cAudio::IRefCounted * SWIGSTDCALL CSharp_IAudioSource_SWIGUpcast(cAudio::IAudioSource *jarg1) { + return (cAudio::IRefCounted *)jarg1; +} + +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; +} + +#ifdef __cplusplus +} +#endif + diff --git a/cAudioCSharpWrapper/src/cAudioWrapped_wrap.h b/cAudioCSharpWrapper/src/cAudioWrapped_wrap.h new file mode 100644 index 0000000..39a0959 --- /dev/null +++ b/cAudioCSharpWrapper/src/cAudioWrapped_wrap.h @@ -0,0 +1,221 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * 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. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_cAudioCSharpWrapper_WRAP_H_ +#define SWIG_cAudioCSharpWrapper_WRAP_H_ + +class SwigDirector_ICaptureEventHandler : public cAudio::ICaptureEventHandler, public Swig::Director { + +public: + SwigDirector_ICaptureEventHandler(); + virtual void onInit(); + virtual void onUpdate(); + virtual void onRelease(); + virtual void onBeginCapture(); + virtual void onEndCapture(); + virtual void onUserRequestBuffer(); + + typedef void (SWIGSTDCALL* SWIG_Callback0_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback1_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback2_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback3_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback4_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback5_t)(); + void 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); + +private: + SWIG_Callback0_t swig_callbackonInit; + SWIG_Callback1_t swig_callbackonUpdate; + SWIG_Callback2_t swig_callbackonRelease; + SWIG_Callback3_t swig_callbackonBeginCapture; + SWIG_Callback4_t swig_callbackonEndCapture; + SWIG_Callback5_t swig_callbackonUserRequestBuffer; + void swig_init_callbacks(); +}; + +class SwigDirector_IDataSource : public cAudio::IDataSource, public Swig::Director { + +public: + SwigDirector_IDataSource(); + virtual ~SwigDirector_IDataSource(); + virtual bool isValid(); + virtual int getCurrentPos(); + virtual int getSize(); + virtual int read(void *output, int size); + virtual bool seek(int amount, bool relative); + + typedef unsigned int (SWIGSTDCALL* SWIG_Callback0_t)(); + typedef int (SWIGSTDCALL* SWIG_Callback1_t)(); + typedef int (SWIGSTDCALL* SWIG_Callback2_t)(); + typedef int (SWIGSTDCALL* SWIG_Callback3_t)(void *, int); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback4_t)(int, unsigned int); + void swig_connect_director(SWIG_Callback0_t callbackisValid, SWIG_Callback1_t callbackgetCurrentPos, SWIG_Callback2_t callbackgetSize, SWIG_Callback3_t callbackread, SWIG_Callback4_t callbackseek); + +private: + SWIG_Callback0_t swig_callbackisValid; + SWIG_Callback1_t swig_callbackgetCurrentPos; + SWIG_Callback2_t swig_callbackgetSize; + SWIG_Callback3_t swig_callbackread; + SWIG_Callback4_t swig_callbackseek; + void swig_init_callbacks(); +}; + +class SwigDirector_IDataSourceFactory : public cAudio::IDataSourceFactory, public Swig::Director { + +public: + SwigDirector_IDataSourceFactory(); + virtual ~SwigDirector_IDataSourceFactory(); + virtual cAudio::IDataSource *CreateDataSource(char const *filename, bool streamingRequested); + + typedef void * (SWIGSTDCALL* SWIG_Callback0_t)(char *, unsigned int); + void swig_connect_director(SWIG_Callback0_t callbackCreateDataSource); + +private: + SWIG_Callback0_t swig_callbackCreateDataSource; + void swig_init_callbacks(); +}; + +class SwigDirector_ILogReceiver : public cAudio::ILogReceiver, public Swig::Director { + +public: + SwigDirector_ILogReceiver(); + virtual bool OnLogMessage(char const *sender, char const *message, cAudio::LogLevel level, float time); + + typedef unsigned int (SWIGSTDCALL* SWIG_Callback0_t)(char *, char *, int, float); + void swig_connect_director(SWIG_Callback0_t callbackOnLogMessage); + +private: + SWIG_Callback0_t swig_callbackOnLogMessage; + void swig_init_callbacks(); +}; + +class SwigDirector_IManagerEventHandler : public cAudio::IManagerEventHandler, public Swig::Director { + +public: + SwigDirector_IManagerEventHandler(); + virtual void onInit(); + virtual void onUpdate(); + virtual void onRelease(); + virtual void onSourceCreate(); + virtual void onDecoderRegister(); + virtual void onDataSourceRegister(); + + typedef void (SWIGSTDCALL* SWIG_Callback0_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback1_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback2_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback3_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback4_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback5_t)(); + void 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); + +private: + SWIG_Callback0_t swig_callbackonInit; + SWIG_Callback1_t swig_callbackonUpdate; + SWIG_Callback2_t swig_callbackonRelease; + SWIG_Callback3_t swig_callbackonSourceCreate; + SWIG_Callback4_t swig_callbackonDecoderRegister; + SWIG_Callback5_t swig_callbackonDataSourceRegister; + void swig_init_callbacks(); +}; + +class SwigDirector_ISourceEventHandler : public cAudio::ISourceEventHandler, public Swig::Director { + +public: + SwigDirector_ISourceEventHandler(); + virtual void onUpdate(); + virtual void onRelease(); + virtual void onPlay(); + virtual void onStop(); + virtual void onPause(); + + typedef void (SWIGSTDCALL* SWIG_Callback0_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback1_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback2_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback3_t)(); + typedef void (SWIGSTDCALL* SWIG_Callback4_t)(); + void swig_connect_director(SWIG_Callback0_t callbackonUpdate, SWIG_Callback1_t callbackonRelease, SWIG_Callback2_t callbackonPlay, SWIG_Callback3_t callbackonStop, SWIG_Callback4_t callbackonPause); + +private: + SWIG_Callback0_t swig_callbackonUpdate; + SWIG_Callback1_t swig_callbackonRelease; + SWIG_Callback2_t swig_callbackonPlay; + SWIG_Callback3_t swig_callbackonStop; + SWIG_Callback4_t swig_callbackonPause; + void swig_init_callbacks(); +}; + +class SwigDirector_IAudioDecoder : public cAudio::IAudioDecoder, public Swig::Director { + +public: + SwigDirector_IAudioDecoder(cAudio::IDataSource *stream); + virtual ~SwigDirector_IAudioDecoder(); + virtual cAudio::AudioFormats getFormat(); + virtual int getFrequency(); + virtual bool isSeekingSupported(); + virtual bool isValid(); + virtual int readAudioData(void *output, int amount); + virtual bool setPosition(int position, bool relative); + virtual bool seek(float seconds, bool relative); + virtual float getTotalTime(); + virtual int getTotalSize(); + virtual int getCompressedSize(); + virtual float getCurrentTime(); + virtual int getCurrentPosition(); + virtual int getCurrentCompressedPosition(); + + typedef int (SWIGSTDCALL* SWIG_Callback0_t)(); + typedef int (SWIGSTDCALL* SWIG_Callback1_t)(); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback2_t)(); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback3_t)(); + typedef int (SWIGSTDCALL* SWIG_Callback4_t)(void *, int); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback5_t)(int, unsigned int); + typedef unsigned int (SWIGSTDCALL* SWIG_Callback6_t)(float, unsigned int); + typedef float (SWIGSTDCALL* SWIG_Callback7_t)(); + typedef int (SWIGSTDCALL* SWIG_Callback8_t)(); + typedef int (SWIGSTDCALL* SWIG_Callback9_t)(); + typedef float (SWIGSTDCALL* SWIG_Callback10_t)(); + typedef int (SWIGSTDCALL* SWIG_Callback11_t)(); + typedef int (SWIGSTDCALL* SWIG_Callback12_t)(); + void swig_connect_director(SWIG_Callback0_t callbackgetFormat, SWIG_Callback1_t callbackgetFrequency, SWIG_Callback2_t callbackisSeekingSupported, SWIG_Callback3_t callbackisValid, SWIG_Callback4_t callbackreadAudioData, SWIG_Callback5_t callbacksetPosition, SWIG_Callback6_t callbackseek, SWIG_Callback7_t callbackgetTotalTime, SWIG_Callback8_t callbackgetTotalSize, SWIG_Callback9_t callbackgetCompressedSize, SWIG_Callback10_t callbackgetCurrentTime, SWIG_Callback11_t callbackgetCurrentPosition, SWIG_Callback12_t callbackgetCurrentCompressedPosition); + +private: + SWIG_Callback0_t swig_callbackgetFormat; + SWIG_Callback1_t swig_callbackgetFrequency; + SWIG_Callback2_t swig_callbackisSeekingSupported; + SWIG_Callback3_t swig_callbackisValid; + SWIG_Callback4_t swig_callbackreadAudioData; + SWIG_Callback5_t swig_callbacksetPosition; + SWIG_Callback6_t swig_callbackseek; + SWIG_Callback7_t swig_callbackgetTotalTime; + SWIG_Callback8_t swig_callbackgetTotalSize; + SWIG_Callback9_t swig_callbackgetCompressedSize; + SWIG_Callback10_t swig_callbackgetCurrentTime; + SWIG_Callback11_t swig_callbackgetCurrentPosition; + SWIG_Callback12_t swig_callbackgetCurrentCompressedPosition; + void swig_init_callbacks(); +}; + +class SwigDirector_IAudioDecoderFactory : public cAudio::IAudioDecoderFactory, public Swig::Director { + +public: + SwigDirector_IAudioDecoderFactory(); + virtual ~SwigDirector_IAudioDecoderFactory(); + virtual cAudio::IAudioDecoder *CreateAudioDecoder(cAudio::IDataSource *stream); + + typedef void * (SWIGSTDCALL* SWIG_Callback0_t)(void *); + void swig_connect_director(SWIG_Callback0_t callbackCreateAudioDecoder); + +private: + SWIG_Callback0_t swig_callbackCreateAudioDecoder; + void swig_init_callbacks(); +}; + + +#endif