/// <summary>
/// Get MediaItem position in CurrentPlaylist or -1 when not found,
/// need for "InsertMediaItem(int atPosition, MediaItem item)"
/// </summary>
public int MediaItemPosition(MediaItem item)
{
return currentPlaylist.GetMediaItemIndex(item);
}
private void DoOnMediaItemEndPlay(object sender, MediaItem item)
{
Console.WriteLine("MediaItem End Play = " + item.MediaFile);
Console.WriteLine();
}
private NetStreamHelper NewNetStreamHelper(MediaItem item)
{
NetStreamHelper nth = null;
if (netConnection != null && netConnection.IsConnected)
{
nth = new NetStreamHelper();
nth.NetStream = new NetStream(netConnection, false);
nth.NetStream.OnAssignStream_ID += new NS_OnAssignStream_ID(NS_OnAssignStream_ID);
nth.Item = item;
nth.Buffer = new CircularBlockBuffer(Convert.ToInt32(((128 * 1024) / 8) * 30)); // 30 seconden buffer voor 128kbit mp3 stream (= 480kb)
// renumber
for (int i = 0; i < netStreams.Count; i++)
{
netStreams[i].IndexNumberInList = i;
} //for
nth.IndexNumberInList = netStreams.Count;
}
return nth;
}
private void DoOnNextMediaItemChanged(object sender, MediaItem oldMediaItem, MediaItem newMediaItem)
{
if (newMediaItem == null)
{
AddLogLine("Next Media = None");
lNext.Text = "";
}
else
{
AddLogLine("Next Media = " + newMediaItem.MediaFile);
lNext.Text = newMediaItem.MediaFile;
}
}
private void DoOnMediaItemSeekEnd(object sender, MediaItem item)
{
Console.WriteLine("SeekEnd (" + item.MediaFile + ")");
}
/// <summary>
/// Remove and MediaItem from the playlist
/// </summary>
public bool RemoveMediaItem(MediaItem item)
{
return RemoveMediaItem(item.GUID);
}
private void DoOnNextMediaItemChanged(object sender, MediaItem oldMediaItem, MediaItem newMediaItem)
{
if (OnNextMediaItemChanged != null)
{
MP_Params param = new MP_Params();
param.Params = new object[] { OnNextMediaItemChanged, this, oldMediaItem, newMediaItem };
SynchronizationContext sc;
lock (lockVAR)
{
sc = synchronizationContext;
} //lock
if (sc != null)
{
sc.Post(HandleOnEventCallUserCode, param);
}
else
{
HandleOnEventCallUserCode(param);
}
}
DoEvent_MP_OnControleButtonStateChange(OnControleButtonStateChange, this);
}
/// <summary>
/// Deep clone
/// </summary>
public object Clone()
{
MediaItem clone = new MediaItem();
clone.GUID = new Guid(GUID.ToString());
clone.MediaFile = MediaFile;
clone.SkipBecauseOfError = SkipBecauseOfError;
clone.NetStreamDurationInMS = NetStreamDurationInMS;
clone.MetaDurationInMS = MetaDurationInMS;
if (MetaData is ICloneable)
{
clone.MetaData = (MediaItemMetaData)(MetaData as ICloneable).Clone();
}
else
{
clone.MetaData = MetaData;
}
if (Tag is ICloneable)
{
clone.Tag = (Tag as ICloneable).Clone();
}
else
{
clone.Tag = Tag;
}
clone._ShuffleDone = _ShuffleDone;
return clone;
}
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] // hide it for code completion
protected internal bool InsertMediaItem(int atPosition, MediaItem item)
{
if (atPosition < 0)
{
atPosition = 0;
}
int oldPreviousMediaItemIndex = PreviousMediaItemIndex;
int oldCurrentMediaItemIndex = CurrentMediaItemIndex;
int oldNextMediaItemIndex = NextMediaItemIndex;
lock (lockVAR)
{
// Check if not too many tracks in playlist
if (playlist.Count >= MAX_MEDIAITEMS)
{
return false;
}
// Check GUID is unique. This is a requirment for the playlist to work correctly!!!
foreach (MediaItem tmpItem in playlist)
{
if (item.GUID.Equals(tmpItem.GUID))
{
return false;
}
} //foreach
// Pre checks are done, we can continue
item._ShuffleDone = false;
if (atPosition <= previousMediaItemIndex)
{
// correct previousMediaItem index
previousMediaItemIndex++;
}
if (atPosition <= currentMediaItemIndex)
{
playlist.Insert(atPosition, item);
currentMediaItemIndex++;
}
else
{
if (atPosition >= playlist.Count)
{
playlist.Add(item);
}
else
{
playlist.Insert(atPosition, item);
}
}
// Maak eerste item actief
if (!CheckIndexValidInPlaylist(currentMediaItemIndex))
{
if (playlist.Count <= 0)
{
currentMediaItemIndex = -1;
}
else
{
currentMediaItemIndex = 0;
}
}
if (oldPreviousMediaItemIndex >= atPosition)
{
oldPreviousMediaItemIndex++;
}
if (oldNextMediaItemIndex >= atPosition)
{
oldNextMediaItemIndex++;
}
//correct historyList
for (int i = 0; i < previousHistoryList.Count; i++)
{
if (previousHistoryList[i] >= atPosition)
{
previousHistoryList[i]++;
}
} //foreach
// When going to 2 items a "next" has a new chance to become valid
if ((shuffleMode && playlist.Count == 2) || !shuffleMode)
{
nextMediaItemIndex = CalcNextMediaItem(false);
}
if (!shuffleMode)
{
// when not in shuflemode previous will not change in subsequent calc to CalcPreviousMediaItem as long
// as currentMediaItemIndex stays the same (content can off course change)
previousMediaItemIndex = CalcPreviousMediaItem(currentMediaItemIndex);
}
}
int newPreviousMediaItemIndex = PreviousMediaItemIndex;
int newCurrentMediaItemIndex = CurrentMediaItemIndex;
int newNextMediaItemIndex = NextMediaItemIndex;
// Fire event playlist has changed
if (OnPlaylistChanged != null)
{
OnPlaylistChanged(this, this);
}
// Do we need to fire an event that the previous MediaItem has changed?
if (oldPreviousMediaItemIndex != newPreviousMediaItemIndex && OnCurrentMediaItemChanged != null)
{
OnCurrentMediaItemChanged(this, SafeSelectClonedMediaItem(oldPreviousMediaItemIndex), SafeSelectClonedMediaItem(newPreviousMediaItemIndex));
}
// Do we need to fire an event that the current MediaItem has changed?
if (oldCurrentMediaItemIndex != newCurrentMediaItemIndex && OnCurrentMediaItemChanged != null)
{
OnCurrentMediaItemChanged(this, SafeSelectClonedMediaItem(oldCurrentMediaItemIndex), SafeSelectClonedMediaItem(newCurrentMediaItemIndex));
}
// Do we need to fire an event that the next MediaItem has changed?
if (oldNextMediaItemIndex != newNextMediaItemIndex && OnNextMediaItemChanged != null)
{
OnNextMediaItemChanged(this, SafeSelectClonedMediaItem(oldNextMediaItemIndex), SafeSelectClonedMediaItem(newNextMediaItemIndex));
}
return true;
}
private void MP_OnPreBuffer(object sender, MediaItem mediaItem, PreBufferState state)
{
switch (state)
{
case PreBufferState.PrebufferingStarted:
lPreBuf.BackColor = Color.Orange;
lPreBuf.Visible = true;
break;
case PreBufferState.PrebufferingReady:
lPreBuf.BackColor = Color.Green;
lPreBuf.Visible = true;
break;
case PreBufferState.PrebufferingEndedAndPlaying:
case PreBufferState.PrebufferingEndedAndCanceled:
case PreBufferState.Unknown:
default:
lPreBuf.Visible = false;
break;
} //switch
}
private void bInsert_Click(object sender, EventArgs e)
{
if (mediaplayer != null && lbPlaylist.SelectedIndex >= 0)
{
MediaItem item = new MediaItem("MP3:Kriss_-_03_-_jazz_club.mp3");
item.MetaDurationInMS = ((5 * 60) + 25) * 1000;
mediaplayer.InsertMediaItem(PlaylistPosition.Next, item);
UpdateScreenPlaylist();
}
}
private void DoOnMediaItemEndPlay(object sender, MediaItem item)
{
AddLogLine("MediaItem End Play = " + item.MediaFile);
AddLogLine("");
}
private void DoOnMediaItemSeekEnd(object sender, MediaItem item)
{
AddLogLine("SeekEnd (" + item.MediaFile + ")");
}
private void DoOnMediaItemStartPlay(object sender, MediaItem item)
{
lFilename.Text = item.MediaFile;
AddLogLine("");
AddLogLine("MediaItem Start Play = " + item.MediaFile);
int count = 0;
foreach (MediaItem mediaItem in mediaplayer.CurrentPlaylist)
{
if (item.GUID.Equals(mediaItem.GUID))
{
lbPlaylist.SelectedIndex = count;
break;
}
count++;
} //foreach
}
/// <summary>
/// Insert a MediaItem at the specified location.
/// </summary>
public bool InsertMediaItem(int atPosition, MediaItem item)
{
MediaItem preBufferedItem = null;
lock (lockVAR)
{
if (netStreams.Count > 1)
{
preBufferedItem = netStreams[1].Item;
}
} //lock
bool result = currentPlaylist.InsertMediaItem(atPosition, item);
MediaItem nextBufferedItem = currentPlaylist.NextMediaItem;
if (preBufferedItem != null && nextBufferedItem != null && item.GUID.Equals(nextBufferedItem.GUID))
{
MP_Message message = new MP_Message();
message.MethodCall = MP_MethodCall.KillPreBufferedMediaItem;
AddMessageToPump(message);
}
return result;
}
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] // hide it for code completion
protected internal bool ChangeCurrentMediaItem(MediaItem newItem, bool addCurrentToPreviousHistory)
{
// Should only be changed by "Mediaplayer" class!!
lock (lockVAR)
{
bool found = true;
int index = -1;
if (newItem != null)
{
// First find selected item
found = false;
foreach (MediaItem item in playlist)
{
index++;
if (item.GUID.Equals(newItem.GUID))
{
// found
found = true;
break;
}
} //foreach
}
if (!found)
{
index = -1;
}
// Let this property handle it all
return ChangeCurrentMediaItemIndex(index, addCurrentToPreviousHistory);
} //lock
}
/// <summary>
/// Insert a MediaItem at the specified location.
/// </summary>
public bool InsertMediaItem(PlaylistPosition position, MediaItem item)
{
return InsertMediaItem(currentPlaylist.AtPositionInsertMediaItem(position), item);
}
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)] // hide it for code completion
protected internal int GetMediaItemIndex(MediaItem mediaItem)
{
return GetMediaItemIndex(mediaItem.GUID);
}
/// <summary>
/// Change the to be played MediaItem
/// </summary>
public bool ChangeCurrentMediaItem(MediaItem newItem, bool addCurrentToPreviousHistory)
{
return currentPlaylist.ChangeCurrentMediaItem(newItem, addCurrentToPreviousHistory);
}
private void DoOnNextMediaItemChanged(object sender, MediaItem oldMediaItem, MediaItem newMediaItem)
{
if (newMediaItem == null)
{
Console.WriteLine("Next Media = None");
}
else
{
Console.WriteLine("Next Media = " + newMediaItem.MediaFile);
}
}
private void DoEvent_MP_OnPreBuffer(MP_OnPreBuffer doEvent, object sender, MediaItem mediaItem, PreBufferState state)
{
if (doEvent != null && mediaItem != null)
{
MP_Params param = new MP_Params();
param.Params = new object[] { doEvent, sender, mediaItem, state };
SynchronizationContext sc;
lock (lockVAR)
{
sc = synchronizationContext;
} //lock
if (sc != null)
{
sc.Post(HandleOnEventCallUserCode, param);
}
else
{
HandleOnEventCallUserCode(param);
}
}
}
private void NewPlaylist()
{
if (mediaplayer != null)
{
mediaplayer.ClearPlaylist();
MediaItem item;
item = new MediaItem("MP3:Comfort_Fit_-_03_-_Sorry.mp3");
item.MetaDurationInMS = ((3 * 60) + 21) * 1000;
mediaplayer.InsertMediaItem(PlaylistPosition.Last, item);
item = new MediaItem("MP3:Kriss_-_03_-_jazz_club.mp3");
item.MetaDurationInMS = ((5 * 60) + 25) * 1000;
mediaplayer.InsertMediaItem(PlaylistPosition.Last, item);
item = new MediaItem("MP3:Monopole_-_02_-_Stereo-vision_radio.mp3");
item.MetaDurationInMS = ((8 * 60) + 16) * 1000;
mediaplayer.InsertMediaItem(PlaylistPosition.Last, item);
item = new MediaItem("MP3:Paper_Navy_-_08_-_Swan_Song.mp3");
item.MetaDurationInMS = ((3 * 56) + 18) * 1000;
mediaplayer.InsertMediaItem(PlaylistPosition.Last, item);
}
}
