public bool Release()
        {
            lock (Mutex)
            {
                try
                {
                    if (mDevice == null)
                    {
                        return(true);
                    }

                    //STOP CAMERA
                    //if (mDevice.RemoteNodeList.GetNodePresent("AcquisitionAbort"))
                    //{
                    //    mDevice.RemoteNodeList["AcquisitionAbort"].Execute();
                    //}
                    //    mDevice.RemoteNodeList["AcquisitionStop"].Execute();

                    //STOP  DataStream acquisition
                    mDataStream.StopAcquisition();
                    mBufferList.DiscardAllBuffers();

                    //RESET EVENT MODE TO UNREGISTERED
                    mDataStream.UnregisterNewBufferEvent();
                    mDataStream.RegisterNewBufferEvent(BGAPI2.Events.EventMode.UNREGISTERED);

                    //Release buffers
                    while (mBufferList.Count > 0)
                    {
                        mBuffer = (BGAPI2.Buffer)mBufferList.Values.First();
                        mBufferList.RevokeBuffer(mBuffer);
                    }

                    //CLOSE
                    mDataStream.Close();
                    mDevice.Close();
                }
                catch (BGAPI2.Exceptions.IException ex)
                {
                    string str;
                    str = string.Format("ExceptionType:{0}! ErrorDescription:{1} in function:{2}", ex.GetType(), ex.GetErrorDescription(), ex.GetFunctionName());
                    //     MessageBox.Show(str);
                    return(false);
                }

                return(true);
            }
        }
        void AcquisitionStart()
        {
            Helpers.Log.LogThisInfo("DEVICE PARAMETER SETUP\n");
            Helpers.Log.LogThisInfo("######################\n\n");

            IsProcessing = true;
            try
            {
                //SET TRIGGER MODE OFF (FreeRun)
                Helpers.Log.LogThisInfo("         TriggerMode:             {0}\n", (string)mDevice.RemoteNodeList["TriggerMode"].Value);

                if (Parameters.TriggerMode)
                {
                    mDevice.RemoteNodeList["TriggerMode"].Value     = "On";
                    mDevice.RemoteNodeList["LineSelector"].Value    = "Line1";
                    mDevice.RemoteNodeList["TriggerSource"].Value   = "All";                  //Or Line0
                    mDevice.RemoteNodeList["LineSelector"].Value    = "Line1";
                    mDevice.RemoteNodeList["LineSource"].Value      = "Line0";
                    mDevice.RemoteNodeList["LineInverter"].Value    = false;
                    mDevice.RemoteNodeList["UserOutputValue"].Value = true;
                    mDevice.RemoteNodeList["TriggerDelay"].Value    = (double)Parameters.TriggerDelay;
                }
                else
                {
                    mDevice.RemoteNodeList["TriggerMode"].Value  = "Off";
                    mDevice.RemoteNodeList["LineInverter"].Value = false;
                }
                if (mDevice.GetRemoteNodeList().GetNodePresent("ExposureTime"))
                {
                    sExposureNodeName = "ExposureTime";
                }
                else if (mDevice.GetRemoteNodeList().GetNodePresent("ExposureTimeAbs"))
                {
                    sExposureNodeName = "ExposureTimeAbs";
                }

                //get current value and limits
                //Parameters.ExposureValue = (double)mDevice.RemoteNodeList[sExposureNodeName].Value;
                Parameters.ExposureMin = (double)mDevice.RemoteNodeList[sExposureNodeName].Min;
                Parameters.ExposureMax = (double)mDevice.RemoteNodeList[sExposureNodeName].Max;

                if (Parameters.ExposureValue < Parameters.ExposureMin)
                {
                    Parameters.ExposureValue = Parameters.ExposureMin;
                }

                if (Parameters.ExposureValue > Parameters.ExposureMax)
                {
                    Parameters.ExposureValue = Parameters.ExposureMax;
                }

                mDevice.RemoteNodeList[sExposureNodeName].Value = Parameters.ExposureValue;

                Helpers.Log.LogThisInfo("         ==>Line Selector:             {0}\n         ==>Trigger Source:             {1}\n         ==>Line Source:             {2}\n         ==>Line Inverter:             {3}\n", mDevice.RemoteNodeList["LineSelector"].Value, mDevice.RemoteNodeList["TriggerSource"].Value, mDevice.RemoteNodeList["LineSource"].Value, mDevice.RemoteNodeList["Line Inverter"].Value);
            }
            catch (BGAPI2.Exceptions.IException ex)
            {
                Helpers.Log.LogThisInfo("ExceptionType:    {0} \n", ex.GetType());
                Helpers.Log.LogThisInfo("ErrorDescription: {0} \n", ex.GetErrorDescription());
                Helpers.Log.LogThisInfo("in function:      {0} \n", ex.GetFunctionName());
            }


            Helpers.Log.LogThisInfo("DATA STREAM LIST\n");
            Helpers.Log.LogThisInfo("################\n\n");

            try
            {
                //COUNTING AVAILABLE DATASTREAMS
                datastreamList = mDevice.DataStreams;
                datastreamList.Refresh();

                //Helpers.Log.LogThisInfo("5.1.8   Detected datastreams:     {0}\n", datastreamList.Count);
                ////DATASTREAM INFORMATION BEFORE OPENING
                //foreach (KeyValuePair<string, BGAPI2.DataStream> dst_pair in datastreamList)
                //{
                //    Helpers.Log.LogThisInfo("  5.2.4   DataStream ID:          {0}\n\n", dst_pair.Key);
                //}
            }
            catch (BGAPI2.Exceptions.IException ex)
            {
                Helpers.Log.LogThisInfo("ExceptionType:    {0} \n", ex.GetType());
                Helpers.Log.LogThisInfo("ErrorDescription: {0} \n", ex.GetErrorDescription());
                Helpers.Log.LogThisInfo("in function:      {0} \n", ex.GetFunctionName());
            }


            Helpers.Log.LogThisInfo("DATA STREAM\n");
            Helpers.Log.LogThisInfo("###########\n\n");

            //OPEN THE FIRST DATASTREAM IN THE LIST
            try
            {
                foreach (KeyValuePair <string, BGAPI2.DataStream> dst_pair in datastreamList)
                {
                    Helpers.Log.LogThisInfo("5.1.9   Open first datastream \n");
                    Helpers.Log.LogThisInfo("          DataStream ID:          {0}\n\n", dst_pair.Key);
                    //if (dst_pair.Value.IsOpen || dst_pair.Value.IsGrabbing )
                    //{
                    if (mDevice.RemoteNodeList.GetNodePresent("AcquisitionAbort") == true)
                    {
                        mDevice.RemoteNodeList["AcquisitionAbort"].Execute();
                        Helpers.Log.LogThisInfo("5.1.12   {0} aborted\n", mDevice.Model);
                    }

                    mDevice.RemoteNodeList["AcquisitionStop"].Execute();
                    //dst_pair.Value.Close();
                    System.Threading.Thread.Sleep(50);
                    //}
                    dst_pair.Value.Open();
                    sDataStreamID = dst_pair.Key;
                    Helpers.Log.LogThisInfo("        Opened datastream - NodeList Information \n");
                    Helpers.Log.LogThisInfo("          StreamAnnounceBufferMinimum:  {0}\n", dst_pair.Value.NodeList["StreamAnnounceBufferMinimum"].Value);
                    if (dst_pair.Value.TLType == "GEV")
                    {
                        Helpers.Log.LogThisInfo("          StreamDriverModel:            {0}\n", dst_pair.Value.NodeList["StreamDriverModel"].Value);
                    }
                    Helpers.Log.LogThisInfo("  \n");
                    break;
                }
            }
            catch (BGAPI2.Exceptions.IException ex)
            {
                Helpers.Log.LogThisInfo("ExceptionType:    {0} \n", ex.GetType());
                Helpers.Log.LogThisInfo("ErrorDescription: {0} \n", ex.GetErrorDescription());
                Helpers.Log.LogThisInfo("in function:      {0} \n", ex.GetFunctionName());
            }

            if (sDataStreamID == "")
            {
                Helpers.Log.LogThisInfo(" No DataStream found \n");
                Helpers.Log.LogThisInfo("\nEnd\nInput any number to close the program:\n");
                //Console.Read();
                mDevice.Close();
                mInterface.Close();
                mSystem.Close();
                IsProcessing = false;
                return;
            }
            else
            {
                mDataStream = datastreamList[sDataStreamID];
            }


            Helpers.Log.LogThisInfo("BUFFER LIST\n");
            Helpers.Log.LogThisInfo("###########\n\n");

            try
            {
                //BufferList
                bufferList = mDataStream.BufferList;

                // 4 buffers using internal buffer mode
                for (int i = 0; i < InternalBufferCount; i++)
                {
                    mBuffer = new BGAPI2.Buffer();
                    bufferList.Add(mBuffer);
                    mBuffer.QueueBuffer();
                }
                Helpers.Log.LogThisInfo("5.1.10   Announced buffers:       {0} using {1} [bytes]\n", bufferList.AnnouncedCount, mBuffer.MemSize * bufferList.AnnouncedCount);
            }
            catch (BGAPI2.Exceptions.IException ex)
            {
                Helpers.Log.LogThisInfo("ExceptionType:    {0} \n", ex.GetType());
                Helpers.Log.LogThisInfo("ErrorDescription: {0} \n", ex.GetErrorDescription());
                Helpers.Log.LogThisInfo("in function:      {0} \n", ex.GetFunctionName());
            }
            Helpers.Log.LogThisInfo("\n");

            Helpers.Log.LogThisInfo("CAMERA START\n");
            Helpers.Log.LogThisInfo("############\n\n");

            mDataStream.RegisterNewBufferEvent(BGAPI2.Events.EventMode.EVENT_HANDLER);
            System.Console.Write("        Register Event Mode to:   {0}\n\n", mDataStream.EventMode.ToString());
            mDataStream.NewBufferEvent += new BGAPI2.Events.DataStreamEventControl.NewBufferEventHandler(mDataStream_NewBufferEvent);

            //START DATASTREAM ACQUISITION
            try
            {
                mDataStream.StartAcquisition();
                Helpers.Log.LogThisInfo("5.1.12   DataStream started \n");
            }
            catch (BGAPI2.Exceptions.IException ex)
            {
                Helpers.Log.LogThisInfo("ExceptionType:    {0} \n", ex.GetType());
                Helpers.Log.LogThisInfo("ErrorDescription: {0} \n", ex.GetErrorDescription());
                Helpers.Log.LogThisInfo("in function:      {0} \n", ex.GetFunctionName());
            }

            //START CAMERA
            try
            {
                mDevice.RemoteNodeList["AcquisitionStart"].Execute();
                Helpers.Log.LogThisInfo("5.1.12   {0} started \n", mDevice.Model);
            }
            catch (BGAPI2.Exceptions.IException ex)
            {
                Helpers.Log.LogThisInfo("ExceptionType:    {0} \n", ex.GetType());
                Helpers.Log.LogThisInfo("ErrorDescription: {0} \n", ex.GetErrorDescription());
                Helpers.Log.LogThisInfo("in function:      {0} \n", ex.GetFunctionName());
            }

            Status = BaumerStatus.Ready;
        }