private void DisconnectFromCall()
{
_videoSender.Detach();
_audioSender.Detach();
if (_videoSender == null || _audioSender == null)
{
return;
}
_connector.Disconnect(_cameraVideo, _videoSender);
_connector.Disconnect(_cameraAudio, _audioSender);
}
private void CloseCamera()
{
if (Camera == null)
{
return;
}
//Connector.Disconnect(Camera.VideoChannel, ImageProvider);
Connector.Disconnect(Camera.VideoChannel, Snapshot);
Camera.Disconnect();
Camera.Dispose();
Camera = null;
}
/// <summary>
/// Occurs when the phone call state has changed.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void call_CallStateChanged(object sender, VoIPEventArgs <CallState> e)
{
InvokeGUIThread(() => { labelCallStateInfo.Text = e.Item.ToString(); });
switch (e.Item)
{
case CallState.InCall:
if (microphone != null)
{
microphone.Start();
}
connector.Connect(microphone, mediaSender);
if (speaker != null)
{
speaker.Start();
}
connector.Connect(mediaReceiver, speaker);
mediaSender.AttachToCall(call);
mediaReceiver.AttachToCall(call);
break;
case CallState.Completed:
if (microphone != null)
{
microphone.Stop();
}
connector.Disconnect(microphone, mediaSender);
if (speaker != null)
{
speaker.Stop();
}
connector.Disconnect(mediaReceiver, speaker);
mediaSender.Detach();
mediaReceiver.Detach();
WireDownCallEvents();
call = null;
InvokeGUIThread(() => { labelDialingNumber.Text = string.Empty; });
break;
case CallState.Cancelled:
WireDownCallEvents();
call = null;
break;
}
}
/// <summary>
/// Disconnects the audio handling devices from each other.
/// </summary>
private void DisconnectMedia()
{
if (_microphone != null)
{
_connector.Disconnect(_microphone, _mediaSender);
}
if (_speaker != null)
{
_connector.Disconnect(_mediaReceiver, _speaker);
}
// You can close all of the connections by using: connector.Dispose();
}
private void button4_Click_1(object sender, EventArgs e)
{
try
{
_connector.Disconnect(_player.VideoChannel, _provider);
_connector.Disconnect(_player.AudioChannel, speaker);
_player.Stop();
speaker.Stop();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
protected override void OnClientDisconnected(IIPCameraClient client)
{
_connector.Disconnect(_camera.AudioChannel, _client.AudioChannel);
_connector.Disconnect(_camera.VideoChannel, _client.VideoChannel);
_connector.Dispose();
var handler = ClientCountChange;
if (handler != null)
{
handler(null, new EventArgs());
}
base.OnClientDisconnected(client);
}
private void button_Connect_Click(object sender, EventArgs e)
{
if (_camera != null)
{
_camera.CameraStateChanged -= _camera_CameraStateChanged;
_camera.Disconnect();
_connector.Disconnect(_camera.VideoChannel, _provider);
_camera.Dispose();
_camera = null;
}
_camera = new OzekiCamera(_myCameraUrlBuilder.CameraURL);
_camera.CameraStateChanged += _camera_CameraStateChanged;
_connector.Connect(_camera.VideoChannel, tripwire);
_connector.Connect(tripwire, _provider);
//upitno
//_connector.Connect(_camera.VideoChannel, tripwire2);
//_connector.Connect(tripwire2, _provider);
//upitno
_camera.Start();
videoViewerWF1.Start();
}
private void TestMikrofonubutton_Click(object sender, RoutedEventArgs e)
{
if (!CzyUruchomionyTest)
{
TaskDoTestow = new Task(() =>
{
MediaConnector mediaConnector = new MediaConnector();
mediaConnector.Connect(microphone, speaker);
microphone.Start();
speaker.Start();
while (CzyUruchomionyTest)
{
;
}
mediaConnector.Disconnect(microphone, speaker);
microphone.Stop();
speaker.Stop();
});
TaskDoTestow.Start();
CzyUruchomionyTest = true;
TestMikrofonubutton.Content = "Zatrzymaj test";
TestGlosnikabutton.IsEnabled = false;
}
else
{
CzyUruchomionyTest = false;
TestMikrofonubutton.Content = "Testuj wejście audio";
TestGlosnikabutton.IsEnabled = true;
}
}
private void close()
{
try
{
videoViewer.Stop();
connector.Disconnect(webCamera.VideoChannel, provider);
groupBox1.Controls.Clear();
webCamera.Stop();
if (mjpegConnection == null)
{
return;
}
vvideoViewer.Stop();
vconnector.Disconnect(mjpegConnection.VideoChannel, vprovider);
mjpegConnection.Disconnect();
groupBox.Controls.Clear();
lblStatus.Text = "Server & camera stopped\n" + lblStatus.Text;
ClientDisconnect();
ServerDisconnect();
}
catch (Exception ex)
{
lblStatus.Text = ex.ToString() + "\n" + lblStatus.Text;
}
}
/// <summary>
/// Disconnecting the microphone and speaker from the call
/// </summary>
private void DisconnectDevicesFromCall()
{
if (microphone != null)
{
microphone.Stop();
}
connector.Disconnect(microphone, mediaSender);
if (speaker != null)
{
speaker.Stop();
}
connector.Disconnect(mediaReceiver, speaker);
mediaSender.Detach();
mediaReceiver.Detach();
}
private void StreamingStopped(object sender, EventArgs e)
{
_log.Info("Done playing file");
_connector.Disconnect(_wavPlayback, _callSender);
_callSender.Detach();
_sendToneComplete = true;
CheckAndComplete();
}
/// <summary>
/// Disconnects the audio handling devices from each other.
/// </summary>
private void DisconnectMedia()
{
if (_microphone != null)
{
_connector.Disconnect(_microphone, _mediaSender);
}
if (_speaker != null)
{
_connector.Disconnect(_mediaReceiver, _speaker);
}
// If you would like to disconnect all of the connections, you can use this line:
// connector.Dispose();
// Please not that, the media handler won't be disposed, only the connections.
}
public void Start(Camera model)
{
if (Model != null)
{
Connector.Disconnect(Model.VideoSender, bitmapSourceProvider);
}
bitmapSourceProvider = new BitmapSourceProvider();
Viewer.SetImageProvider(bitmapSourceProvider);
Connector = new MediaConnector();
Model = model;
Connector.Connect(model.VideoSender, bitmapSourceProvider);
Viewer.Start();
}
private void CaptureStop()
{
if (_camera.VideoChannel == null)
{
return;
}
_connector.Disconnect(_camera.VideoChannel, _recorder.VideoRecorder);
_recorder.Multiplex();
}
private void DisconnectMedia()
{
try
{
if (MicrPhone != null)
{
Conector.Disconnect(MicrPhone, MediaSender);
}
if (Speakers != null)
{
Conector.Disconnect(MediaReciever, Speakers);
}
}
catch (Exception ex)
{
InvokeGUIThread(mymsg = ("Cant start media: " + ex));
}
}
/// <summary>
/// Changes the microphone device.
/// </summary>
public void ChangeMicrophone(AudioDeviceInfo deviceInfo)
{
if (!_initialized)
{
return;
}
float prevVolume = 0;
bool prevMuted = false;
if (Microphone != null)
{
// same device
if (Microphone.DeviceInfo.Equals(deviceInfo))
{
return;
}
// backup settings
prevVolume = Microphone.Volume;
prevMuted = Microphone.Muted;
// dispose previous device
_audioConnector.Disconnect(Microphone, AudioEnhancer);
UnsubscribeFromMicrophoneEvents();
Microphone.Dispose();
}
// create new microphone
Microphone = Microphone.GetDevice(deviceInfo);
if (Microphone != null)
{
SubscribeToMicrophoneEvents();
_audioConnector.Connect(Microphone, AudioEnhancer);
// set prev device settings
Microphone.Volume = prevVolume;
Microphone.Muted = prevMuted;
Microphone.Start();
}
OnPropertyChanged("Microphone");
}
private void StopMp3Ring()
{
if (mp3Player != null && _speaker != null)
{
mediaConnector.Disconnect(mp3Player, _speaker);
mediaConnector.Dispose();
mp3Player.Dispose();
_speaker.Stop();
}
}
protected override void OnClientDisconnected(IIPCameraClient client)
{
_client = client;
_connector.Disconnect(Model.AudioSender, _client.AudioChannel);
_connector.Disconnect(Model.VideoSender, _client.VideoChannel);
_connector.Dispose();
var handler = ClientCountChange;
if (handler != null)
{
handler(null, new EventArgs());
}
base.OnClientDisconnected(_client);
Log.Write("Client Disconnected: " + _client.TransportInfo.RemoteEndPoint + " Local: " + _client.TransportInfo.LocalEndPoint);
}
private void Disconnect()
{
if (Model == null)
{
return;
}
connector.Disconnect(Model.VideoSender, bitmapSourceProvider);
Viewer.Stop();
}
public void DisconnectMedia()
{
if (microphone != null)
{
connector.Disconnect(microphone, mediaSender);
}
if (speaker != null)
{
connector.Disconnect(mediaReceiver, speaker);
}
if (camera != null)
{
//connector.Disconnect(camera.VideoChannel, Instance.LocalProvider);
connector.Disconnect(camera.VideoChannel, videoSender);
}
connector.Disconnect(videoReceiver, remoteProvider);
}
private void CallEnded()
{
_log.Info("Audio position at " + _wavRecorder.Stream.Position);
_log.Info("Call Completed");
_wavRecorder.StopStreaming();
_connector.Disconnect(_audioReceiver, _mixer);
_connector.Disconnect(_mixer, _wavRecorder);
_wavRecorder.Stream.Flush();
_wavRecorder.Dispose();
_wavRecorder = null;
_audioReceiver.Detach();
_log.Info("Call tear down done");
// Wake up the main thread
_complete = true;
lock (_sync)
{
Monitor.Pulse(_sync);
}
}
public void StopRecording()
{
if (_videoSender == null)
{
return;
}
_connector.Disconnect(_videoSender, _recorder.VideoRecorder);
_recorder.Multiplex();
VideoFilesManager.CheckMemoryLimitForAllVideos(_configuration.VideosFolderPath);
}
public void Connect(string Domain, string userName, string Password)
{
if (_camera != null)
{
_camera.CameraStateChanged -= _CameraStateChanged;
_camera.Disconnect();
_mediaConnector.Disconnect(_camera.VideoChannel, _Imageprovider);
_camera.Dispose();
_camera = null;
}
//_camera = IPCameraFactory.GetCamera("192.168.7.37:80", "admin", "12345hik");
_camera = IPCameraFactory.GetCamera(Domain, userName, Password);
//stateCamera
_camera.CameraStateChanged += _CameraStateChanged;
_mediaConnector.Connect(_camera.VideoChannel, _Imageprovider);
//_connector.Connect(_camera.VideoChannel, _snapShot);
_camera.Start();
_videoViewer.Start();
}
private void CloseCamera()
{
if (Camera == null)
{
return;
}
_imageMask.Stop();
Camera.Stop();
Connector.Disconnect(Camera.VideoChannel, ImageProvider);
Camera = null;
}
public void DeAttachVoIPHandlerToCall(VoIPMediaHandler voIPMediaHandler)
{
AudioHandler handler = voIPMediaHandler as AudioHandler;
if (handler == null)
{
return;
}
if (voIPMediaHandler is WaveStreamRecorder || voIPMediaHandler is MP3StreamRecorder)
{
mediaConnector.Connect(incomingAudioMixer, handler);
}
else
{
mediaConnector.Disconnect(handler, outgoingAudioMixer);
}
}
private void bunifuFlatButton3_Click(object sender, EventArgs e)
{
try
{
if (_mjpegConnection1 == null || _mpeg4Recorder1 == null)
{
return;
}
_mpeg4Recorder1.Multiplex();
_connector1.Disconnect(_mjpegConnection1.AudioChannel, _mpeg4Recorder1.AudioRecorder);
_connector1.Disconnect(_mjpegConnection1.VideoChannel, _mpeg4Recorder1.VideoRecorder);
MessageBox.Show("Stop video recording");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
MessageBox.Show("Please enter IP, Username and Password !");
}
}
private void btnDisconnect3_Click(object sender, EventArgs e)
{
try
{
if (_mjpegConnection3 == null)
{
return;
}
_mjpegConnection3.Disconnect();
_connector3.Disconnect(_mjpegConnection3.VideoChannel, _bitmapSourceProvider3);
_connector3.Disconnect(_mjpegConnection3.VideoChannel, _snapShot3);
videoViewerWF3.Stop();
bunifuMaterialTextbox9.Text = "";
bunifuMaterialTextbox11.Text = "";
bunifuMaterialTextbox12.Text = "";
bunifuMaterialTextbox10.Text = "";
videoViewerWF3.ClearScreen();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
MessageBox.Show("Please enter IP, Username and Password !");
}
}
private void mPEG4Recorder_MultiplexFinished(object sender, EventArgs e)
{
_connector.Disconnect(_camera.AudioChannel, _mpeg4Recorder.AudioRecorder);
_connector.Disconnect(_camera.VideoChannel, _mpeg4Recorder.VideoRecorder);
_mpeg4Recorder.Dispose();
}
private void Mpeg4Recorder_MultiplexFinished(object sender, Ozeki.VoIP.VoIPEventArgs <bool> e)
{
_connector.Disconnect(_camera.AudioChannel, _mpeg4Recorder.AudioRecorder);
_connector.Disconnect(_camera.VideoChannel, _mpeg4Recorder.VideoRecorder);
_mpeg4Recorder.Dispose();
}
/// <summary>
/// Helper method to disconnect webcam.
/// </summary>
private void DisconnectCamera()
{
_mediaConnector.Disconnect(_webCamera, _imageProvider);
_webCamera.Stop();
_videoViewer.Stop();
}
