Example #1
0
        private static SampleArray CreateSincTable(int windowSize, int resolution, float cornerRatio, Func <float, int, float> windowFunction)
        {
            var subWindow = ((windowSize / 2) + 1);
            var table     = new SampleArray((subWindow * resolution));
            var gain      = 2.0 * cornerRatio;

            for (int x = 0; x < subWindow; x++)
            {
                for (int y = 0; y < resolution; y++)
                {
                    var a    = x + (y / (float)(resolution));
                    var sinc = SynthConstants.TwoPi * cornerRatio * a;
                    if (Math.Abs(sinc) > 0.00001)
                    {
                        sinc = Math.Sin(sinc) / sinc;
                    }
                    else
                    {
                        sinc = 1.0;
                    }
                    table[x * SynthConstants.SincResolution + y] = (float)(gain * sinc * windowFunction(a, windowSize));
                }
            }
            return(table);
        }
Example #2
0
        public void AddSamples(SampleArray samples)
        {
            var uint8 = new Uint8Array(samples.ToFloat32Array().Buffer);
            var b64   = Script.Write <string>("untyped __js__(\"window.btoa(String.fromCharCode.apply(null, {0}))\", uint8)");

            FlashOutput.AlphaSynthAddSamples(b64);
        }
        public void AddSamples(SampleArray samples)
        {
            var uint8 = new Uint8Array(samples.Buffer);
            var b64   = JsCode("window.btoa(String.fromCharCode.apply(null, uint8))").As <string>();

            document.getElementById(_swfId).As <IFlashSynthOutput>().AlphaSynthAddSamples(b64);
        }
Example #4
0
        private void Interpolate(GeneratorParameters generatorParams, SampleArray blockBuffer, double increment, int start, int end)
        {
            double _end = generatorParams.CurrentState == GeneratorState.Loop ? this.LoopEndPhase - 1 : this.EndPhase - 1;
            int    index;
            float  s1, s2, mu;

            while (start < end && generatorParams.Phase < _end)//do this until we reach an edge case or fill the buffer
            {
                index = (int)generatorParams.Phase;
                s1    = Samples[index];
                s2    = Samples[index + 1];
                mu    = (float)(generatorParams.Phase - index);
                blockBuffer[start++]   = s1 + mu * (s2 - s1);
                generatorParams.Phase += increment;
            }
            while (start < end)//edge case, if in loop wrap to loop start else use duplicate sample
            {
                index = (int)generatorParams.Phase;
                s1    = Samples[index];
                if (generatorParams.CurrentState == GeneratorState.Loop)
                {
                    s2 = Samples[(int)generatorParams.CurrentStart];
                }
                else
                {
                    s2 = s1;
                }
                mu = (float)(generatorParams.Phase - index);
                blockBuffer[start++]   = s1 + mu * (s2 - s1);
                generatorParams.Phase += increment;
            }
        }
        public void TestInstantiation()
        {
            var testInstance = new SampleArray();

            Assert.AreEqual(testInstance.GroceryList.Length, 4);
            Assert.AreEqual(testInstance.GroceryList[1], "Tomatoes");
        }
        private void GenerateSound(AudioProcessingEvent e)
        {
            var left    = e.OutputBuffer.GetChannelData(0);
            var right   = e.OutputBuffer.GetChannelData(1);
            var samples = left.Length + right.Length;

            if (_circularBuffer.Count < samples)
            {
                if (_finished)
                {
                    Finished();
                }
            }
            else
            {
                var buffer = new SampleArray(samples);
                _circularBuffer.Read(buffer, 0, buffer.Length);

                var s = 0;
                for (int i = 0; i < left.Length; i++)
                {
                    left[i]  = buffer[s++];
                    right[i] = buffer[s++];
                }

                SamplesPlayed(left.Length);
            }



            if (!_finished)
            {
                RequestBuffers();
            }
        }
        public override int Read(float[] buffer, int offset, int count)
        {
            if (_circularBuffer.Count < count)
            {
                if (_finished)
                {
                    Finished();
                }
            }
            else
            {
                var read = new SampleArray(count);
                _circularBuffer.Read(read, 0, read.Length);

                for (int i = 0; i < count; i++)
                {
                    buffer[offset + i] = read[i];
                }

                var samples = count / 2;
                SamplesPlayed(samples);
            }

            if (!_finished)
            {
                RequestBuffers();
            }

            return(count);
        }
Example #8
0
        public void AddSamples(SampleArray samples)
        {
            var        uint8        = new Uint8Array(samples.Buffer);
            JsFunction fromCharCode = JsCode("String.fromCharCode").As <JsFunction>();
            var        b64          = window.btoa(fromCharCode.apply(null, uint8.As <object[]>()).As <string>());

            document.getElementById(_swfId).As <IFlashSynthOutput>().AlphaSynthAddSamples(b64);
        }
Example #9
0
 public void AddSamples(SampleArray f)
 {
     for (int i = 0; i < f.Length; i++)
     {
         Samples.Add(f[i]);
     }
     SamplesPlayed(f.Length);
 }
Example #10
0
 public void SetAudioChannelCount(int channels)
 {
     channels = SynthHelper.ClampI(channels, 1, 2);
     if (AudioChannels != channels)
     {
         AudioChannels = channels;
         SampleBuffer  = new SampleArray((MicroBufferSize * MicroBufferCount * AudioChannels));
     }
 }
Example #11
0
        private static SampleArray CreateSustainTable(int size)
        {
            var table = new SampleArray(size);

            for (int x = 0; x < size; x++)
            {
                table[x] = 1;
            }
            return(table);
        }
Example #12
0
        private static SampleArray CreateCentTable()
        {//-100 to 100 cents
            var cents = new SampleArray(201);

            for (int x = 0; x < cents.Length; x++)
            {
                cents[x] = (float)Math.Pow(2.0, (x - 100.0) / 1200.0);
            }
            return(cents);
        }
Example #13
0
        private static SampleArray CreateSemitoneTable()
        {//-127 to 127 semitones
            var table = new SampleArray(255);

            for (int x = 0; x < table.Length; x++)
            {
                table[x] = (float)Math.Pow(2.0, (x - 127.0) / 12.0);
            }
            return(table);
        }
Example #14
0
        private static SampleArray CreateLinearTable(int size)
        {
            var table = new SampleArray(size);

            for (int x = 0; x < size; x++)
            {
                table[x] = x / (float)(size - 1);
            }
            return(table);
        }
Example #15
0
    public void TestArray()
    {
        var sample = new SampleArray
        {
            Fields = { "b", "c" }
        };
        var count = sample.Fields.Count;

        Assert.Equal(2, count);
    }
Example #16
0
 private static SampleArray RemoveDenormals(SampleArray data)
 {
     for (int x = 0; x < data.Length; x++)
     {
         if (Math.Abs(data[x]) < SynthConstants.DenormLimit)
         {
             data[x] = 0;
         }
     }
     return(data);
 }
Example #17
0
        private static SampleArray CreateSineTable(int size)
        {
            var graph = new SampleArray(size);
            var inc   = (float)(3.0 * Math.PI / 2.0) / (size - 1);
            var phase = 0.0;

            for (int x = 0; x < size; x++)
            {
                graph[x] = (float)Math.Abs(Math.Sin(phase));
                phase   += inc;
            }
            return(graph);
        }
Example #18
0
        public Synthesizer(int sampleRate, int audioChannels, int bufferSize, int bufferCount, int polyphony)
        {
            var MinSampleRate = 8000;
            var MaxSampleRate = 96000;

            if (sampleRate < MinSampleRate || sampleRate > MaxSampleRate)
            {
                throw new Exception("Invalid paramater: (sampleRate) Valid ranges are " + MinSampleRate + " to " +
                                    MaxSampleRate);
            }
            if (audioChannels < 1 || audioChannels > 2)
            {
                throw new Exception("Invalid paramater: (audioChannels) Valid ranges are " + 1 + " to " + 2);
            }

            _midiMessageProcessed = new FastList <Action <MidiEvent> >();
            //
            // Setup synth parameters
            _synthGain    = 0.35f;
            _masterVolume = 1;

            SampleRate      = sampleRate;
            AudioChannels   = audioChannels;
            MicroBufferSize = SynthHelper.ClampI(bufferSize, (int)(SynthConstants.MinBufferSize * sampleRate),
                                                 (int)(SynthConstants.MaxBufferSize * sampleRate));
            MicroBufferSize =
                (int)
                (Math.Ceiling(MicroBufferSize / (double)SynthConstants.DefaultBlockSize) *
                 SynthConstants.DefaultBlockSize);     //ensure multiple of block size
            MicroBufferCount = (Math.Max(1, bufferCount));
            SampleBuffer     = new SampleArray((MicroBufferSize * MicroBufferCount * audioChannels));
            LittleEndian     = true;

            //Setup Controllers
            _synthChannels = new SynthParameters[SynthConstants.DefaultChannelCount];
            for (int x = 0; x < _synthChannels.Length; x++)
            {
                _synthChannels[x] = new SynthParameters(this);
            }
            //Create synth voices
            _voiceManager = new VoiceManager(SynthHelper.ClampI(polyphony, SynthConstants.MinPolyphony, SynthConstants.MaxPolyphony));
            //Create midi containers
            MidiEventQueue  = new LinkedList <SynthEvent>();
            MidiEventCounts = new int[MicroBufferCount];
            _layerList      = new Patch[15];

            _midiMessageProcessed = new FastList <Action <MidiEvent> >();
            ResetSynthControls();
        }
Example #19
0
        private static void Init()
        {
            var EnvelopeSize     = 64;
            var ExponentialCoeff = .09f;

            _envelopeTables    = new SampleArray[4];
            _envelopeTables[0] = (RemoveDenormals(CreateSustainTable(EnvelopeSize)));
            _envelopeTables[1] = (RemoveDenormals(CreateLinearTable(EnvelopeSize)));
            _envelopeTables[2] = (RemoveDenormals(CreateExponentialTable(EnvelopeSize, ExponentialCoeff)));
            _envelopeTables[3] = (RemoveDenormals(CreateSineTable(EnvelopeSize)));
            _centTable         = CreateCentTable();
            _semitoneTable     = CreateSemitoneTable();
            _sincTable         = CreateSincTable(SynthConstants.SincWidth, SynthConstants.SincResolution, .43f, HammingWindow);
            _isInitialized     = true;
        }
Example #20
0
        private static SampleArray CreateExponentialTable(int size, float coeff)
        {
            coeff = SynthHelper.ClampF(coeff, .001f, .9f);
            var graph = new SampleArray(size);
            var val   = 0.0;

            for (int x = 0; x < size; x++)
            {
                graph[x] = (float)val;
                val     += coeff * ((1 / 0.63) - val);
            }
            for (int x = 0; x < size; x++)
            {
                graph[x] = graph[x] / graph[graph.Length - 1];
            }
            return(graph);
        }
Example #21
0
        private void GenerateSound(DOMEvent e)
        {
            var ae      = (AudioProcessingEvent)e;
            var left    = ae.outputBuffer.getChannelData(0);
            var right   = ae.outputBuffer.getChannelData(1);
            var samples = left.length + right.length;

            if (_circularBuffer.Count < samples)
            {
                if (_finished)
                {
                    if (Finished != null)
                    {
                        Finished();
                    }
                    Stop();
                }
                else
                {
                    // when buffering we count it as pause time
                    _pauseTime += (int)((BufferSize * 1000) / (2 * _context.sampleRate));
                }
            }
            else
            {
                var buffer = new SampleArray(samples);
                _circularBuffer.Read(buffer, 0, buffer.Length);

                var s = 0;
                for (int i = 0; i < left.length; i++)
                {
                    left[i]  = buffer[s++];
                    right[i] = buffer[s++];
                }
            }

            if (PositionChanged != null)
            {
                PositionChanged((int)(CalcPosition()));
            }

            if (!_finished)
            {
                RequestBuffers();
            }
        }
Example #22
0
        public virtual void GetValues(GeneratorParameters generatorParams, SampleArray blockBuffer, double increment)
        {
            var proccessed = 0;

            do
            {
                var samplesAvailable = (int)(Math.Ceiling((generatorParams.CurrentEnd - generatorParams.Phase) / increment));
                if (samplesAvailable > blockBuffer.Length - proccessed)
                {
                    while (proccessed < blockBuffer.Length)
                    {
                        blockBuffer[proccessed++] = GetValue(generatorParams.Phase);
                        generatorParams.Phase    += increment;
                    }
                }
                else
                {
                    var endProccessed = proccessed + samplesAvailable;
                    while (proccessed < endProccessed)
                    {
                        blockBuffer[proccessed++] = GetValue(generatorParams.Phase);
                        generatorParams.Phase    += increment;
                    }
                    switch (generatorParams.CurrentState)
                    {
                    case GeneratorState.PreLoop:
                        generatorParams.CurrentStart = LoopStartPhase;
                        generatorParams.CurrentEnd   = LoopEndPhase;
                        generatorParams.CurrentState = GeneratorState.Loop;
                        break;

                    case GeneratorState.Loop:
                        generatorParams.Phase += generatorParams.CurrentStart - generatorParams.CurrentEnd;
                        break;

                    case GeneratorState.PostLoop:
                        generatorParams.CurrentState = GeneratorState.Finished;
                        while (proccessed < blockBuffer.Length)
                        {
                            blockBuffer[proccessed++] = 0;
                        }
                        break;
                    }
                }
            } while (proccessed < blockBuffer.Length);
        }
Example #23
0
 public VoiceParameters()
 {
     BlockBuffer = new SampleArray(SynthConstants.DefaultBlockSize);
     //create default number of each component
     PData           = new UnionData[SynthConstants.MaxVoiceComponents];
     GeneratorParams = new GeneratorParameters[SynthConstants.MaxVoiceComponents];
     Envelopes       = new Envelope[SynthConstants.MaxVoiceComponents];
     Filters         = new Filter[SynthConstants.MaxVoiceComponents];
     Lfos            = new Lfo[SynthConstants.MaxVoiceComponents];
     //initialize each component
     for (int x = 0; x < SynthConstants.MaxVoiceComponents; x++)
     {
         GeneratorParams[x] = new GeneratorParameters();
         Envelopes[x]       = new Envelope();
         Filters[x]         = new Filter();
         Lfos[x]            = new Lfo();
     }
 }
Example #24
0
        private static SampleArray CreateSquareTable(int size, int k)
        {//Uses Fourier Expansion up to k terms
            var FourOverPi  = 4 / Math.PI;
            var squaretable = new SampleArray(size);
            var inc         = 1.0 / size;
            var phase       = 0.0;

            for (int x = 0; x < size; x++)
            {
                var value = 0.0;
                for (int i = 1; i < k + 1; i++)
                {
                    var twokminus1 = (2 * i) - 1;
                    value += Math.Sin(SynthConstants.TwoPi * (twokminus1) * phase) / (twokminus1);
                }
                squaretable[x] = SynthHelper.ClampF((float)(FourOverPi * value), -1, 1);
                phase         += inc;
            }
            return(squaretable);
        }
Example #25
0
        public void ApplyFilterInterp(SampleArray data, int sampleRate)
        {
            float[] ic     = GenerateFilterCoeff(CutOff / sampleRate, Resonance);
            float   a1_inc = (ic[0] - _a1) / data.Length;
            float   a2_inc = (ic[1] - _a2) / data.Length;
            float   b1_inc = (ic[2] - _b1) / data.Length;
            float   b2_inc = (ic[3] - _b2) / data.Length;

            switch (FilterMethod)
            {
            case FilterType.BiquadHighpass:
            case FilterType.BiquadLowpass:
                for (int x = 0; x < data.Length; x++)
                {
                    _a1    += a1_inc;
                    _a2    += a2_inc;
                    _b1    += b1_inc;
                    _b2    += b2_inc;
                    _m3     = data[x] - _a1 * _m1 - _a2 * _m2;
                    data[x] = _b2 * (_m3 + _m2) + _b1 * _m1;
                    _m2     = _m1;
                    _m1     = _m3;
                }
                _a1 = ic[0];
                _a2 = ic[1];
                _b1 = ic[2];
                _b2 = ic[3];
                break;

            case FilterType.OnePoleLowpass:
                for (int x = 0; x < data.Length; x++)
                {
                    _a1    += a1_inc;
                    _m1    += _a1 * (data[x] - _m1);
                    data[x] = _m1;
                }
                _a1 = ic[0];
                break;
            }
            CoeffNeedsUpdating = false;
        }
Example #26
0
        public override int Read(float[] buffer, int offset, int count)
        {
            if (_circularBuffer.Count < count)
            {
                if (_finished)
                {
                    if (Finished != null)
                    {
                        Finished();
                    }
                    Stop();
                }
                else
                {
                    // when buffering we count it as pause time
                    _pauseTime += (BufferSize * 1000) / (2 * WaveFormat.SampleRate);
                }
            }
            else
            {
                var read = new SampleArray(count);
                _circularBuffer.Read(read, 0, read.Length);

                for (int i = 0; i < count; i++)
                {
                    buffer[offset + i] = read[i];
                }
            }

            if (PositionChanged != null)
            {
                PositionChanged((int)(CalcPosition()));
            }

            if (!_finished)
            {
                RequestBuffers();
            }

            return(count);
        }
Example #27
0
File: Speed.cs Project: klenin/Yuzu
        public void TestJsonLongArrayStr()
        {
            var list1 = new SampleArray { A = new string[100000] };
            for (int i = 0; i < list1.A.Length; ++i)
                list1.A[i] = i.ToString();

            var js = new JsonSerializer();
            js.JsonOptions.ArrayLengthPrefix = true;
            var result1 = js.ToString(list1);
            Assert.IsTrue(result1 != "");

            var list2 = new SampleArray();
            var jd = new JsonDeserializer();
            jd.JsonOptions.ArrayLengthPrefix = true;
            jd.FromString(list2, result1);
            Assert.AreEqual(list1.A.Length, list2.A.Length);

            var jdg = new SampleArray_JsonDeserializer();
            var list3 = (SampleArray)jdg.FromString(result1);
            Assert.AreEqual(list1.A.Length, list3.A.Length);
        }
Example #28
0
        public override void GetValues(GeneratorParameters generatorParams, SampleArray blockBuffer, double increment)
        {
            int proccessed = 0;

            do
            {
                int samplesAvailable = (int)Math.Ceiling((generatorParams.CurrentEnd - generatorParams.Phase) / increment);
                if (samplesAvailable > blockBuffer.Length - proccessed)
                {
                    Interpolate(generatorParams, blockBuffer, increment, proccessed, blockBuffer.Length);
                    return; //proccessed = blockBuffer.Length;
                }
                else
                {
                    int endProccessed = proccessed + samplesAvailable;
                    Interpolate(generatorParams, blockBuffer, increment, proccessed, endProccessed);
                    proccessed = endProccessed;
                    switch (generatorParams.CurrentState)
                    {
                    case GeneratorState.PreLoop:
                        generatorParams.CurrentStart = LoopStartPhase;
                        generatorParams.CurrentEnd   = LoopEndPhase;
                        generatorParams.CurrentState = GeneratorState.Loop;
                        break;

                    case GeneratorState.Loop:
                        generatorParams.Phase += generatorParams.CurrentStart - generatorParams.CurrentEnd;
                        break;

                    case GeneratorState.PostLoop:
                        generatorParams.CurrentState = GeneratorState.Finished;
                        while (proccessed < blockBuffer.Length)
                        {
                            blockBuffer[proccessed++] = 0f;
                        }
                        break;
                    }
                }
            }while (proccessed < blockBuffer.Length);
        }
Example #29
0
        public Synthesizer(int sampleRate, int audioChannels, int bufferSize, int bufferCount, int polyphony)
        {
            var MinSampleRate = 8000;
            var MaxSampleRate = 96000;

            //
            // Setup synth parameters
            MasterVolume = 1;

            SampleRate       = SynthHelper.ClampI(sampleRate, MinSampleRate, MaxSampleRate);
            MicroBufferSize  = SynthHelper.ClampI(bufferSize, (int)(SynthConstants.MinBufferSize * sampleRate), (int)(SynthConstants.MaxBufferSize * sampleRate));
            MicroBufferSize  = (int)(Math.Ceiling(MicroBufferSize / (double)SynthConstants.DefaultBlockSize) * SynthConstants.DefaultBlockSize); //ensure multiple of block size
            MicroBufferCount = (Math.Max(1, bufferCount));
            SampleBuffer     = new SampleArray((MicroBufferSize * MicroBufferCount * audioChannels));

            // Setup Controllers
            _synthChannels = new SynthParameters[SynthConstants.DefaultChannelCount];
            for (int x = 0; x < _synthChannels.Length; x++)
            {
                _synthChannels[x] = new SynthParameters(this);
            }

            // setup metronome channel
            _metronomeChannel = _synthChannels.Length - 1;

            // Create synth voices
            _voiceManager = new VoiceManager(SynthHelper.ClampI(polyphony, SynthConstants.MinPolyphony, SynthConstants.MaxPolyphony));

            // Create midi containers
            _midiEventQueue  = new LinkedList <SynthEvent>();
            _midiEventCounts = new int[MicroBufferCount];
            _layerList       = new Patch[15];

            _mutedChannels = new FastDictionary <int, bool>();
            _soloChannels  = new FastDictionary <int, bool>();

            ResetSynthControls();
        }
Example #30
0
        public void ApplyFilter(SampleArray data)
        {
            switch (FilterMethod)
            {
            case FilterType.BiquadHighpass:
            case FilterType.BiquadLowpass:
                for (int x = 0; x < data.Length; x++)
                {
                    _m3     = data[x] - _a1 * _m1 - _a2 * _m2;
                    data[x] = _b2 * (_m3 + _m2) + _b1 * _m1;
                    _m2     = _m1;
                    _m1     = _m3;
                }
                break;

            case FilterType.OnePoleLowpass:
                for (int x = 0; x < data.Length; x++)
                {
                    _m1    += _a1 * (data[x] - _m1);
                    data[x] = _m1;
                }
                break;
            }
        }
Example #31
0
        public void TestArray()
        {
            var bs = new BinarySerializer();
            var bd = new BinaryDeserializer();
            var bdg = new BinaryDeserializerGen();

            var v0 = new SampleArray { A = new string[] { "a", "b", "c" } };
            var result0 = bs.ToBytes(v0);
            Assert.AreEqual(
                "20 01 00 " + XS(typeof(SampleArray)) + " 01 00 " + XS("A", RoughType.Sequence) +
                " 10 01 00 03 00 00 00 " + XS("a", "b", "c") + " 00 00",
                XS(result0));
            var w0 = new SampleArray();
            bd.FromBytes(w0, result0);
            CollectionAssert.AreEqual(v0.A, w0.A);
            var w0g = (SampleArray)bdg.FromBytes(result0);
            CollectionAssert.AreEqual(v0.A, w0g.A);

            var v2 = new SampleArray();
            var result2 = bs.ToBytes(v2);
            Assert.AreEqual("20 01 00 01 00 FF FF FF FF 00 00", XS(result2));
            var w2 = new SampleArray();
            bd.FromBytes(w2, result2);
            CollectionAssert.AreEqual(v2.A, w2.A);
            var w2g = (SampleArray)bdg.FromBytes(result2);
            CollectionAssert.AreEqual(v2.A, w2g.A);
        }
Example #32
0
 internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SampleArray obj) {
   return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 }
Example #33
0
        public void TestArray()
        {
            var js = new JsonSerializer();
            js.JsonOptions.Indent = "";
            var jd = new JsonDeserializer();

            var v0 = new SampleArray { A = new string[] { "a", "b", "c" } };
            var result0 = js.ToString(v0);
            Assert.AreEqual("{\n\"A\":[\n\"a\",\n\"b\",\n\"c\"\n]\n}", result0);
            var w0 = new SampleArray();
            jd.FromString(w0, result0);
            CollectionAssert.AreEqual(v0.A, w0.A);

            // Generated deserializer uses array prefix.
            var w1 = (SampleArray)SampleArray_JsonDeserializer.Instance.FromString(
                "{\n\"A\":[\n3,\n\"a\",\n\"b\",\n\"c\"\n]\n}");
            CollectionAssert.AreEqual(v0.A, w1.A);

            var v2 = new SampleArray();
            var result2 = js.ToString(v2);
            Assert.AreEqual("{\n\"A\":null\n}", result2);
            var w2 = (SampleArray)SampleArray_JsonDeserializer.Instance.FromString(result2);
            CollectionAssert.AreEqual(v2.A, w2.A);
            jd.FromString(w2, result2);
            CollectionAssert.AreEqual(v2.A, w2.A);
        }
Example #34
0
 internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SampleArray obj)
 {
     return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
 }