protected void RendererRecycledConnectionSinkEx(AVRenderer sender, AVConnection connection, object Handle) { TreeNode node = NodeTagSearch(rendererRootNode,connection); if (node != null) { // Connection was recycled, update it node.Text = connection.ConnectionID.ToString() + " - " + connection.CurrentState.ToString(); if (listViewSelectedObject == connection) SetListInfo(connection); } }
protected void RendererCreateConnectionSinkEx(AVRenderer sender, AVConnection connection, object Handle) { TreeNode node = NodeTagSearch(rendererRootNode,connection); if (node != null) { // Connection was recycled, update it node.Text = connection.ConnectionID.ToString() + " - " + connection.CurrentState.ToString(); if (listViewSelectedObject == connection) SetListInfo(connection); } else { // New connection, lets add it to the renderer node = NodeTagSearch(rendererRootNode,sender); if (node == null) MessageBox.Show(this,"Got new connection on unknown renderer"); TreeNode varNode = new TreeNode(connection.ConnectionID.ToString() + " - " + connection.CurrentState.ToString(),1,1); varNode.Tag = connection; node.Nodes.Add(varNode); connection.OnVolume += new AVConnection.VolumeChangedHandler(VolumeChangedHandlerSink); connection.OnPlayStateChanged += new AVConnection.PlayStateChangedHandler(PlayStateChangedHandlerSink); connection.OnMute += new AVConnection.MuteStateChangedHandler(MuteStateChangedHandlerSink); connection.OnPositionChanged += new AVConnection.PositionChangedHandler(PositionChangedHandlerSink); connection.OnMediaResourceChanged += new AVConnection.MediaResourceChangedHandler(MediaResourceChangedHandlerSink); connection.OnRemoved += new AVConnection.RendererHandler(RemovedConnectionHandlerSink); connection.OnTrackChanged += new AVConnection.CurrentTrackChangedHandler(TrackChangedSink); connection.OnCurrentMetaDataChanged += new AVConnection.CurrentMetaDataChangedHandler(MetaDataSink); } }
protected void ConnectionInfoSink(CpConnectionManager sender, System.Int32 ConnectionID, System.Int32 RcsID, System.Int32 AVTransportID, System.String ProtocolInfo, System.String PeerConnectionManager, System.Int32 PeerConnectionID, CpConnectionManager.Enum_A_ARG_TYPE_Direction Direction, CpConnectionManager.Enum_A_ARG_TYPE_ConnectionStatus Status, UPnPInvokeException e, object Handle) { if (e != null) { return; } AVConnection av = null; lock (InstanceList) { foreach (AVConnection a in InstanceList) { if (a.ConnectionID == ConnectionID) { av = a; break; } } if (av == null) { av = new AVConnection(MainDevice, AVTransportID, RcsID, ConnectionID, new AVConnection.OnReadyHandler(ReadySink), Handle); av._Parent = this; InstanceList.Add(av); } else { return; // Don't need to trigger event } } // Wait for Ready before sending OnCreateConnection }
/// <summary> /// This is called when PrepareForConnection was successful /// </summary> /// <param name="sender"></param> /// <param name="c"></param> /// <param name="h"></param> protected void ConnectionSink(AVRenderer sender, AVConnection c, object h) { lock (ConnectionLock) { if (TableOfHandles.ContainsKey(h) == false) { return; } } // OpenSource.Utilities.InstanceTracker.StopTimer("PrepareForConnection"); _AVR.OnCreateConnection2 -= new AVRenderer.ConnectionHandler(ConnectionSink); c.OnCurrentURIChanged += new AVConnection.CurrentURIChangedHandler(UriEventSink); if (this.CurrentPlayListMode == PlayListMode.SINGLE_URI) { c.OnPlayStateChanged += new AVConnection.PlayStateChangedHandler(PlayStateSink); } c.CurrentPlayList = this; OpenSource.Utilities.InstanceTracker.StartTimer(); // c.SetAVTransportURI(PlayListUri, "", c, new CpAVTransport.Delegate_OnResult_SetAVTransportURI(SetURISink)); c.SetAVTransportURI(PlayListUri, PlayListMetaData, c, new CpAVTransport.Delegate_OnResult_SetAVTransportURI(SetURISink)); }
private void PlayListSink(AVPlayList sender, AVConnection c, object Tag) { PlayListTable.Remove(sender.GetHashCode()); if (OnReuseConnection != null) { OnReuseConnection(this, Tag); } }
/// <summary> /// This get called when the URI events are received /// </summary> /// <param name="sender"></param> private void UriEventSink(AVConnection sender) { sender.OnCurrentURIChanged -= new AVConnection.CurrentURIChangedHandler(UriEventSink); this.SetURIEvent_Event.Set(); if (SetURI_Event.WaitOne(0, false) == true) { // OpenSource.Utilities.InstanceTracker.StopTimer("SetAVTransport+Event [evt]"); if (OnReady != null) { OnReady(this, sender, _Tag); } OnReady = null; } }
/// <summary> /// This method is called when an Async call to PrepareForConnection returns. Only /// the AVPlayList class will ever call that method. /// </summary> /// <param name="sender"></param> /// <param name="RemoteProtocolInfo"></param> /// <param name="PeerConnectionManager"></param> /// <param name="PeerConnectionID"></param> /// <param name="Direction"></param> /// <param name="ConnectionID"></param> /// <param name="AVTransportID"></param> /// <param name="RcsID"></param> /// <param name="e"></param> /// <param name="Handle"></param> protected void PrepareForConnectionSink(CpConnectionManager sender, System.String RemoteProtocolInfo, System.String PeerConnectionManager, System.Int32 PeerConnectionID, CpConnectionManager.Enum_A_ARG_TYPE_Direction Direction, System.Int32 ConnectionID, System.Int32 AVTransportID, System.Int32 RcsID, UPnPInvokeException e, object Handle) { AVConnection c = null; bool IsNew = true; if (e != null) { // Since only the AVPlayList class will call PrepareForConnection, we need to fire // this other event, because it's too early to notify the user. Only AVPlayList needs // to know about this, so it can continue to setup the connection for the user OnCreateConnectionFailedEvent2.Fire(this, AVRenderer.CreateFailedReason.CREATE_ATTEMPT_DENIED, Handle); return; } lock (InstanceList) { foreach (AVConnection a in InstanceList) { if (a.ConnectionID == ConnectionID) { // We Already Have this ID From somewhere IsNew = false; c = a; break; } } if (IsNew == true) { // Does not Exist c = new AVConnection(MainDevice, AVTransportID, RcsID, ConnectionID, new AVConnection.OnReadyHandler(_ReadySink), Handle); c._Parent = this; InstanceList.Add(c); } } if (IsNew == true) { // Wait for Ready event from the AVConnection, since we can't return it // until it is initialized. } else { // Recycled OnRecycledConnectionEvent2.Fire(this, c, Handle); } }
/// <summary> /// This constructor is called with the UPnPDevice that contains the services of a MediaRenderer device. /// </summary> /// <param name="device">The UPnPDevice</param> public AVRenderer(UPnPDevice device) { OpenSource.Utilities.InstanceTracker.Add(this); this.ConnectionMonitor.OnExpired += new LifeTimeMonitor.LifeTimeHandler(ConnectionMonitorSink); MainDevice = device; ConnectionManager = new CpConnectionManager(device.GetServices(CpConnectionManager.SERVICE_NAME)[0]); ConnectionManager.OnStateVariable_CurrentConnectionIDs += new CpConnectionManager.StateVariableModifiedHandler_CurrentConnectionIDs(ConnectionIDEventSink); ConnectionManager._subscribe(90); //TODO: Fails to compile after using generated code from DeviceBuilderV23. Seems like CpConnectionManager.PeriodicRenewFailedHandler is no longer defined? //ConnectionManager.OnPeriodicRenewFailed += new CpConnectionManager.PeriodicRenewFailedHandler(PeriodicRenewFailedSink); // Grab initial state of the ConnectionManager Service if (ConnectionManager.HasAction_GetProtocolInfo) { ConnectionManager.GetProtocolInfo(null, new CpConnectionManager.Delegate_OnResult_GetProtocolInfo(GetProtocolInfoSink)); } if (ConnectionManager.HasAction_GetCurrentConnectionIDs) { ConnectionManager.GetCurrentConnectionIDs(null, new CpConnectionManager.Delegate_OnResult_GetCurrentConnectionIDs(IDSink)); } if (ConnectionManager.HasAction_PrepareForConnection == false) { lock (InstanceList) { AVConnection ac = new AVConnection(MainDevice, 0, 0, 0, new AVConnection.OnReadyHandler(ReadySink), null); ac._Parent = this; DontEverDelete = true; if (InstanceList.Count == 0) { InstanceList.Add(ac); } } /* Wait for Ready * if(InstanceList.Count>0) * { * if(OnCreateConnection!=null) OnCreateConnection(this,(AVConnection)InstanceList[0],Guid.NewGuid().GetHashCode()); * } */ } }
protected void PlayListSink(AVPlayList sender, AVConnection c, object Tag) { PlayListTable.Remove(sender.GetHashCode()); lock (this.CreateConnectionLock) { --this.PendingCreateConnection; if (this.PendingCreateConnection < 0) { PendingCreateConnection = 0; } ConnectionMonitor.Remove(c.ConnectionID); } if (sender.IsRecycled) { OnRecycledConnectionEvent.Fire(this, c, Tag); } else { OnCreateConnectionEvent.Fire(this, c, Tag); } }
/// <summary> /// This method gets called when the PlayState of the connection changes /// </summary> /// <param name="sender"></param> /// <param name="NewState"></param> protected void PlayStateSink(AVConnection sender, AVConnection.PlayState NewState) { if (NewState == AVConnection.PlayState.STOPPED) { if (FakePlayQueue.Count == 0) { return; } if (sender.MediaResource.ContentUri != PlayListUri) { // Somebody else changed the Uri from under us, so we have no choice // but to give up FakePlayQueue.Clear(); return; } IMediaResource r = (IMediaResource)FakePlayQueue.Dequeue(); PlayListUri = r.ContentUri; //ToDo: Add MetaData sender.SetAVTransportURI(r.ContentUri, "", sender, new CpAVTransport.Delegate_OnResult_SetAVTransportURI(FakePlayListSink)); } }
/// <summary> /// This is called when PrepareForConnection was successful and /// returned a recycled connection id /// </summary> /// <param name="sender"></param> /// <param name="c"></param> /// <param name="h"></param> protected void RecycledSink(AVRenderer sender, AVConnection c, object h) { lock (ConnectionLock) { if (TableOfHandles.ContainsKey(h) == false) { return; } } _AVR.OnRecycledConnection2 -= new AVRenderer.ConnectionHandler(RecycledSink); IsRecycled = true; c.OnCurrentURIChanged += new AVConnection.CurrentURIChangedHandler(UriEventSink); if (this.CurrentPlayListMode == PlayListMode.SINGLE_URI) { c.OnPlayStateChanged += new AVConnection.PlayStateChangedHandler(PlayStateSink); } c.CurrentPlayList = this; // c.SetAVTransportURI(PlayListUri, "", c, new CpAVTransport.Delegate_OnResult_SetAVTransportURI(this.SetURISink)); c.SetAVTransportURI(PlayListUri, PlayListMetaData, c, new CpAVTransport.Delegate_OnResult_SetAVTransportURI(this.SetURISink)); }
protected void RendererRemovedConnectionSink(AVRenderer sender, AVConnection r, object Handle) { UpdateUserInterface(); }
protected void RendererRecycledConnectionSink(AVRenderer sender, AVConnection r, object Handle) { if (renderer != sender) MessageBox.Show(this,"Incorrect renderer event"); if (r != connection && (connection == null || (long)Handle == PendingConnection)) { if (connection != null) { connection.OnMediaResourceChanged -= new AVConnection.MediaResourceChangedHandler(OnMediaResourceChangedHandlerSink); connection.OnMute -= new AVConnection.MuteStateChangedHandler(MuteStateChangedHandlerSink); connection.OnPlayStateChanged -= new AVConnection.PlayStateChangedHandler(PlayStateChangedHandlerSink); connection.OnPositionChanged -= new AVConnection.PositionChangedHandler(PositionChangedHandlerSink); connection.OnRemoved -= new AVConnection.RendererHandler(RemovedConnectionHandlerSink); connection.OnVolume -= new AVConnection.VolumeChangedHandler(VolumeChangedHandlerSink); } connection = r; connection.OnMediaResourceChanged += new AVConnection.MediaResourceChangedHandler(OnMediaResourceChangedHandlerSink); connection.OnMute += new AVConnection.MuteStateChangedHandler(MuteStateChangedHandlerSink); connection.OnPlayStateChanged += new AVConnection.PlayStateChangedHandler(PlayStateChangedHandlerSink); connection.OnPositionChanged += new AVConnection.PositionChangedHandler(PositionChangedHandlerSink); connection.OnRemoved += new AVConnection.RendererHandler(RemovedConnectionHandlerSink); connection.OnVolume += new AVConnection.VolumeChangedHandler(VolumeChangedHandlerSink); } UpdateUserInterface(); }
private void VolumeChangedHandlerSink(AVConnection sender, UInt16 Volume) { if (connection != sender) return; volumeTrackBar.Value = (int)connection.MasterVolume; }
private void RendererControlForm_Closed(object sender, System.EventArgs e) { if (connection != null) { connection.OnMediaResourceChanged -= new AVConnection.MediaResourceChangedHandler(OnMediaResourceChangedHandlerSink); connection.OnMute -= new AVConnection.MuteStateChangedHandler(MuteStateChangedHandlerSink); connection.OnPlayStateChanged -= new AVConnection.PlayStateChangedHandler(PlayStateChangedHandlerSink); connection.OnPositionChanged -= new AVConnection.PositionChangedHandler(PositionChangedHandlerSink); connection.OnRemoved -= new AVConnection.RendererHandler(RemovedConnectionHandlerSink); connection.OnVolume -= new AVConnection.VolumeChangedHandler(VolumeChangedHandlerSink); connection = null; } parent.RendererControlFormClose(this,renderer); }
private void CurrentTrackChangedHandlerSink(AVConnection sender, uint track) { if (sender != connection) return; if (mediaProgressBar.Tag != null) return; if (InvokeRequired) { Invoke(new CurrentTrackChangedHandler(CurrentTrackChangedHandlerSink), sender, track); return; } UpdateUserInterface(); }
private void MediaResourceChangedHandlerSink(AVConnection connection, IMediaResource res) { if (InvokeRequired) { Invoke(new AVConnection.MediaResourceChangedHandler(MediaResourceChangedHandlerSink), connection, res); return; } if (listViewSelectedObject == connection) SetListInfo(connection); }
private void MuteStateChangedHandlerSink(AVConnection sender, bool NewMuteStatus) { if (sender != connection) return; muteMenuItem.Checked = connection.IsMute; if (connection.IsMute == true) { muteButton.Image = mutedPictureBox.Image; } else { muteButton.Image = mutePictureBox.Image; } }
private void RemovedConnectionHandlerSink(AVConnection connection) { if (InvokeRequired) { Invoke(new AVConnection.RendererHandler(RemovedConnectionHandlerSink), connection); return; } TreeNode node = NodeTagSearch(rendererRootNode, connection); if (node != null) node.Remove(); connection.OnVolume -= new AVConnection.VolumeChangedHandler(VolumeChangedHandlerSink); connection.OnPlayStateChanged -= new AVConnection.PlayStateChangedHandler(PlayStateChangedHandlerSink); connection.OnMute -= new AVConnection.MuteStateChangedHandler(MuteStateChangedHandlerSink); connection.OnPositionChanged -= new AVConnection.PositionChangedHandler(PositionChangedHandlerSink); connection.OnRemoved -= new AVConnection.RendererHandler(RemovedConnectionHandlerSink); connection.OnTrackChanged -= new AVConnection.CurrentTrackChangedHandler(TrackChangedSink); connection.OnCurrentMetaDataChanged -= new AVConnection.CurrentMetaDataChangedHandler(MetaDataSink); }
private void PlayStateChangedHandlerSink(AVConnection connection, AVConnection.PlayState NewState) { if (InvokeRequired) { Invoke(new AVConnection.PlayStateChangedHandler(PlayStateChangedHandlerSink), connection, NewState); return; } TreeNode node = NodeTagSearch(rendererRootNode, connection); if (node != null) { node.Text = connection.ConnectionID.ToString() + " - " + connection.CurrentState.ToString(); } if (listViewSelectedObject == connection) SetListInfo(connection); }
private void _ReadySink(AVConnection sender, object Tag) { OnCreateConnectionEvent2.Fire(this, sender, Tag); }
private void PositionChangedHandlerSink(AVConnection sender, TimeSpan position) { if (sender != connection) return; if (mediaProgressBar.Tag != null) return; if (InvokeRequired) { Invoke(new PositionChangedHandler(PositionChangedHandlerSink), sender, position); return; } UpdateUserInterface(); }
public AVPlayList(AVConnection AVC, IMediaResource[] r, ReadyHandler rh, FailedHandler fh, object Tag) { OpenSource.Utilities.InstanceTracker.Add(this); AVRenderer AVR = AVC.Parent; _AVR = AVR; this.CurrentURIChangedHandler = new AVConnection.CurrentURIChangedHandler(UriEventSink); _Tag = Tag; /* * ArrayList branches = new ArrayList(); * ToXmlData_Custom txdc = new ToXmlData_Custom(); * foreach(IMediaResource R in r) * { * if(branches.Contains(R.Owner)==false) * { * branches.Add(R.Owner); * } * txdc.Mappings[R] = false; * } * * MediaBuilder.container container = new MediaBuilder.container("Autogenerated Playlist"); * container.ID = Guid.NewGuid().ToString(); * container.IdIsValid = true; * ToXmlFormatter txf = new ToXmlFormatter(); * txf.WriteResource = new ToXmlFormatter.ToXml_FormatResource(WriteResource); * txdc.DesiredProperties = new ArrayList(); * txdc.IsRecursive = true; * txdc.VirtualOwner = MediaBuilder.CreateContainer(container); * * // Obtain the DIDL-Lite MetaData * this.PlayListMetaData = MediaBuilder.BuildDidl(txf, txdc, branches); * if(PlayListMetaData.Length>32768) PlayListMetaData = ""; */ int TempHandle = this.GetHashCode(); bool Done = false; OnReady += rh; OnFailed += fh; AVR.OnCreateConnection2 += new AVRenderer.ConnectionHandler(ConnectionSink); AVR.OnRecycledConnection2 += new AVRenderer.ConnectionHandler(RecycledSink); AVR.OnCreateConnectionFailed2 += new AVRenderer.FailedConnectionHandler(FailedSink); if (r.Length == 1) { Done = true; _CurrentPlayListMode = PlayListMode.NOT_A_PLAYLIST; PlayListUri = ConvertLocalFileToHTTPResource(r[0]); lock (ConnectionLock) { TableOfHandles[TempHandle] = TempHandle; ConnectionSink(_AVR, AVC, TempHandle); } } if ((Done == false && AVR.SupportsProtocolInfo(new ProtocolInfoString("http-get:*:audio/mpegurl:*"))) || (Done == false && AVR.SupportsProtocolInfo(new ProtocolInfoString("http-get:*:audio/x-mpegurl:*")))) { // Build M3U Done = true; _CurrentPlayListMode = PlayListMode.M3U; CheckMiniWebServer(); StringBuilder M3U = new StringBuilder(); if (AVPlayList.EnableExtendedM3U) { M3U.Append("#EXTM3U\r\n"); } foreach (IMediaResource R in r) { if (AVPlayList.EnableExtendedM3U) { PrintExtInfLine(M3U, R); } M3U.Append(ConvertLocalFileToHTTPResource(R) + "\r\n"); } M3UString = M3U.ToString(); PlayListUri = "http://" + AVR.Interface.ToString() + ":" + MWS.LocalIPEndPoint.Port.ToString() + "/item.m3u"; lock (ConnectionLock) { TableOfHandles[TempHandle] = TempHandle; ConnectionSink(_AVR, AVC, TempHandle); } } // Use SINGLE_URI if (Done == false) { _CurrentPlayListMode = PlayListMode.SINGLE_URI; foreach (IMediaResource rsc in r) { FakePlayQueue.Enqueue(rsc); } PlayListUri = r[0].ContentUri; FakePlayQueue.Dequeue(); lock (ConnectionLock) { TableOfHandles[TempHandle] = TempHandle; ConnectionSink(_AVR, AVC, TempHandle); } } }
private void CurrentTrackChangedHandlerSink(AVConnection sender, uint track) { if (sender != connection) return; if (mediaProgressBar.Tag != null) return; UpdateUserInterface(); }
private void VolumeChangedHandlerSink(AVConnection connection, UInt16 Volume) { if (InvokeRequired) { Invoke(new AVConnection.VolumeChangedHandler(VolumeChangedHandlerSink), connection, Volume); return; } if (listViewSelectedObject == connection) SetListInfo(connection); }
private void instanceButton_Click(object sender, System.EventArgs e) { int i = renderer.Connections.IndexOf(connection)+1; if (i >= renderer.Connections.Count) i = 0; AVConnection nextconnection = (AVConnection)renderer.Connections[i]; if (nextconnection == null || nextconnection == connection) return; // Unplug the connection connection.OnMediaResourceChanged -= new AVConnection.MediaResourceChangedHandler(OnMediaResourceChangedHandlerSink); connection.OnMute -= new AVConnection.MuteStateChangedHandler(MuteStateChangedHandlerSink); connection.OnPlayStateChanged -= new AVConnection.PlayStateChangedHandler(PlayStateChangedHandlerSink); connection.OnPositionChanged -= new AVConnection.PositionChangedHandler(PositionChangedHandlerSink); connection.OnRemoved -= new AVConnection.RendererHandler(RemovedConnectionHandlerSink); connection.OnVolume -= new AVConnection.VolumeChangedHandler(VolumeChangedHandlerSink); // Setup the new one connection = nextconnection; connection.OnMediaResourceChanged += new AVConnection.MediaResourceChangedHandler(OnMediaResourceChangedHandlerSink); connection.OnMute += new AVConnection.MuteStateChangedHandler(MuteStateChangedHandlerSink); connection.OnPlayStateChanged += new AVConnection.PlayStateChangedHandler(PlayStateChangedHandlerSink); connection.OnPositionChanged += new AVConnection.PositionChangedHandler(PositionChangedHandlerSink); connection.OnRemoved += new AVConnection.RendererHandler(RemovedConnectionHandlerSink); connection.OnVolume += new AVConnection.VolumeChangedHandler(VolumeChangedHandlerSink); UpdateUserInterface(); }
protected void RemovedConnectionSinkEx(AVRenderer sender, AVConnection r, object Handle) { TreeNode node = NodeTagSearch(rendererRootNode,r); if (node != null) { node.Remove(); } }
private void OnMediaResourceChangedHandlerSink(AVConnection sender, IMediaResource target) { UpdateUserInterface(); }
private void VolumeChangedHandlerSink(AVConnection sender, UInt16 volume) { masterTrackBar.Value = (int)connection.MasterVolume; }
private void MuteStateChangedHandlerSink(AVConnection connection, bool NewMuteStatus) { if (InvokeRequired) { Invoke(new AVConnection.MuteStateChangedHandler(MuteStateChangedHandlerSink), connection, NewMuteStatus); return; } if (listViewSelectedObject == connection) SetListInfo(connection); }
private void VolumeChangedHandlerSink(AVConnection sender, UInt16 Volume) { if (connection != sender) return; if (InvokeRequired) { Invoke(new VolumeChangedHandlerSinkHandler(VolumeChangedHandlerSink), sender, Volume); return; } volumeTrackBar.Value = (int)connection.MasterVolume; }
private void PositionChangedHandlerSink(AVConnection connection, TimeSpan time) { if (InvokeRequired) { Invoke(new AVConnection.PositionChangedHandler(PositionChangedHandlerSink), connection, time); return; } if (listViewSelectedObject == connection) { lock (listInfo) { listInfo.Items[1].SubItems[1].Text = connection.CurrentPosition.ToString(); listInfo.Items[4].SubItems[1].Text = connection.Duration.ToString(); } } }
private void PlayStateChangedHandlerSink(AVConnection sender, AVConnection.PlayState NewState) { if (sender != connection) return; playButton.Image = playPictureBox2.Image; recordButton.Image = recordPictureBox2.Image; stopButton.Image = stopPictureBox2.Image; pauseButton.Image = pausePictureBox2.Image; switch (NewState) { case AVConnection.PlayState.PLAYING: playButton.Image = playPictureBox1.Image; playMenuItem.Checked = true; recordMenuItem.Checked = false; stopMenuItem.Checked = false; pauseMenuItem.Checked = false; break; case AVConnection.PlayState.RECORDING: recordButton.Image = recordPictureBox1.Image; playMenuItem.Checked = false; recordMenuItem.Checked = true; stopMenuItem.Checked = false; pauseMenuItem.Checked = false; break; case AVConnection.PlayState.SEEKING: stopButton.Image = stopPictureBox1.Image; playMenuItem.Checked = false; recordMenuItem.Checked = false; stopMenuItem.Checked = true; pauseMenuItem.Checked = false; break; case AVConnection.PlayState.STOPPED: stopButton.Image = stopPictureBox1.Image; playMenuItem.Checked = false; recordMenuItem.Checked = false; stopMenuItem.Checked = true; pauseMenuItem.Checked = false; break; case AVConnection.PlayState.PAUSED: pauseButton.Image = pausePictureBox1.Image; playMenuItem.Checked = false; recordMenuItem.Checked = false; stopMenuItem.Checked = false; pauseMenuItem.Checked = true; break; } }
private void TrackChangedSink(AVConnection connection, UInt32 NewTrack) { if (InvokeRequired) { Invoke(new AVConnection.CurrentTrackChangedHandler(TrackChangedSink), connection, NewTrack); return; } if (listViewSelectedObject == connection) { lock (listInfo) { listInfo.Items[3].SubItems[1].Text = connection.CurrentTrack.ToString(); listInfo.Items[13].SubItems[1].Text = connection.NumberOfTracks.ToString(); } } }
public RendererControlForm(MainForm parent, AVRenderer renderer, AVConnection connection) { // // Required for Windows Form Designer support // InitializeComponent(); this.parent = parent; this.renderer = renderer; this.connection = connection; renderer.OnCreateConnection += new AVRenderer.ConnectionHandler(RendererCreateConnectionSink); renderer.OnRecycledConnection += new AVRenderer.ConnectionHandler(RendererRecycledConnectionSink); renderer.OnRemovedConnection += new AVRenderer.ConnectionHandler(RendererRemovedConnectionSink); if (connection == null && renderer.Connections.Count > 0) { connection = (AVConnection)renderer.Connections[0]; this.connection = connection; } if (connection != null) { connection.OnMediaResourceChanged += new AVConnection.MediaResourceChangedHandler(OnMediaResourceChangedHandlerSink); connection.OnMute += new AVConnection.MuteStateChangedHandler(MuteStateChangedHandlerSink); connection.OnPlayStateChanged += new AVConnection.PlayStateChangedHandler(PlayStateChangedHandlerSink); connection.OnPositionChanged += new AVConnection.PositionChangedHandler(PositionChangedHandlerSink); connection.OnRemoved += new AVConnection.RendererHandler(RemovedConnectionHandlerSink); connection.OnTrackChanged += new AVConnection.CurrentTrackChangedHandler(CurrentTrackChangedHandlerSink); connection.OnVolume += new AVConnection.VolumeChangedHandler(VolumeChangedHandlerSink); volumeTrackBar.Value = (int)connection.MasterVolume; PositionChangedHandlerSink(connection, connection.CurrentPosition); muteMenuItem.Checked = connection.IsMute; if (connection.IsMute == true) { muteButton.Image = mutedPictureBox.Image; } else { muteButton.Image = mutePictureBox.Image; } } this.Text = "Renderer - " + renderer.FriendlyName; rendererNameLabel.Text = renderer.FriendlyName; if (connection != null) PlayStateChangedHandlerSink(connection,connection.CurrentState); UpdateUserInterface(); }
protected void MetaDataSink(AVConnection sender) { if (InvokeRequired) { Invoke(new AVConnection.CurrentMetaDataChangedHandler(MetaDataSink), sender); return; } SetListInfo(listViewSelectedObject); }
protected void RendererRecycledConnectionSink(AVRenderer sender, AVConnection r, object Handle) { Object[] args = new Object[3]; args[0] = sender; args[1] = r; args[2] = Handle; this.Invoke(new AVRenderer.ConnectionHandler(RendererRecycledConnectionSinkEx),args); }
private void PositionChangedHandlerSink(AVConnection sender, TimeSpan position) { if (sender != connection) return; if (mediaProgressBar.Tag != null) return; UpdateUserInterface(); }
private void MuteStateChangedHandlerSink(AVConnection sender, bool NewMuteStatus) { masterMuteCheckBox.Checked = NewMuteStatus; }
private void RemovedConnectionHandlerSink(AVConnection sender) { if (connection == sender) { // Unplug the connection connection.OnMediaResourceChanged -= new AVConnection.MediaResourceChangedHandler(OnMediaResourceChangedHandlerSink); connection.OnMute -= new AVConnection.MuteStateChangedHandler(MuteStateChangedHandlerSink); connection.OnPlayStateChanged -= new AVConnection.PlayStateChangedHandler(PlayStateChangedHandlerSink); connection.OnPositionChanged -= new AVConnection.PositionChangedHandler(PositionChangedHandlerSink); connection.OnRemoved -= new AVConnection.RendererHandler(RemovedConnectionHandlerSink); connection.OnVolume -= new AVConnection.VolumeChangedHandler(VolumeChangedHandlerSink); connection = null; if (renderer.Connections.Count > 0) { connection = (AVConnection)renderer.Connections[0]; connection.OnMediaResourceChanged += new AVConnection.MediaResourceChangedHandler(OnMediaResourceChangedHandlerSink); connection.OnMute += new AVConnection.MuteStateChangedHandler(MuteStateChangedHandlerSink); connection.OnPlayStateChanged += new AVConnection.PlayStateChangedHandler(PlayStateChangedHandlerSink); connection.OnPositionChanged += new AVConnection.PositionChangedHandler(PositionChangedHandlerSink); connection.OnRemoved += new AVConnection.RendererHandler(RemovedConnectionHandlerSink); connection.OnVolume += new AVConnection.VolumeChangedHandler(VolumeChangedHandlerSink); } } UpdateUserInterface(); }
protected void PlayListSink(AVPlayList sender, AVConnection c, object Tag) { PlayListTable.Remove(sender.GetHashCode()); lock(this.CreateConnectionLock) { --this.PendingCreateConnection; if(this.PendingCreateConnection<0) PendingCreateConnection = 0; ConnectionMonitor.Remove(c.ConnectionID); } if(sender.IsRecycled) { OnRecycledConnectionEvent.Fire(this,c,Tag); } else { OnCreateConnectionEvent.Fire(this,c,Tag); } }