public void Load_New_Media()
{
try
{
MediaControl.Stop();
MediaControl.Source = new Uri(getrandomfile2(@"C:\Queuing System\Media\"));
MediaControl.Play();
}
catch
{
Load_New_Media();
}
}
/// <summary>
/// Clean up stuff
/// </summary>
public void Dispose()
{
if (MediaControl != null)
{
MediaControl.Stop();
}
//debug
if (rot != null)
{
rot.Dispose();
rot = null;
}
}
/// <summary>
/// 停止
/// </summary>
public void Stop()
{
CheckAlive();
Status = GraphState.Stopped;
MediaControl.Stop();
long pos = 0;
MediaSeeking.SetPositions(ref pos, AMSeekingSeekingFlags.AbsolutePositioning, ref pos, AMSeekingSeekingFlags.NoPositioning);
MediaControl.StopWhenReady();
if (MediaStop != null)
{
MediaStop(this, EventArgs.Empty);
}
}
private void Media_Stop_Click(object sender, RoutedEventArgs e)
{
if (Model.IsServer)
{
MediaControl.Stop();
}
else
{
NetworkCommunicator.SendAsync(new HarmonyPacket()
{
Type = HarmonyPacket.PacketType.MediaControl,
Pack = new HarmonyPacket.MediaControlPacket()
{
Action = HarmonyPacket.MediaControlPacket.MediaAction.Stop
}
});
}
}
public override void SetCurrentPosition(long time)
{
if (IsGraphSeekable)
{
var state = GraphState;
PauseGraph();
long pStop = 0;
MediaSeeking.SetPositions(ref time, SeekingFlags.AbsolutePositioning, ref pStop, SeekingFlags.NoPositioning);
switch (state)
{
case GraphState.Running:
ResumeGraph();
break;
case GraphState.Stopped:
MediaControl.Stop();
GraphState = GraphState.Stopped;
break;
}
}
}
/// <summary>
/// Actualy run the graph
/// </summary>
private void RunGraph()
{
try
{
Running = true;
while (Running)
{
Thread.Sleep(500);
EventCode ev;
IntPtr p1, p2;
Application.DoEvents();
while (MediaEvent.GetEvent(out ev, out p1, out p2, 0) == 0)
{
if (ev == EventCode.Complete || ev == EventCode.UserAbort || ev == EventCode.ErrorAbort)
{
if (ev == EventCode.ErrorAbort)
{
string msg = DecodeHrResult((uint)p1.ToInt64());
Program.LogError("ERROR: HRESULT={0:X} {1}", p1, msg);
Trace("ERROR: HRESULT={0:X} {1}", p1, msg);
}
MediaControl.Stop();
Running = false;
Trace("Done!");
Program.LogSuccess("Done!");
}
MediaEvent.FreeEventParams(ev, p1, p2);
}
}
Graph.Abort();
Trace("Graph Closed");
}
catch (Exception ex)
{
ExceptionHelper.HandleException(ex);
Trace("ERROR: Running Graph");
}
}
public void Load()
{
GraphBuilder = new FilgraphManager() as IGraphBuilder;
MediaControl = GraphBuilder as IMediaControl;
MediaSeeking = GraphBuilder as IMediaSeeking;
MediaEventEx = GraphBuilder as IMediaEventEx;
MediaFilter = GraphBuilder as IMediaFilter;
thread = new Tsukikage.Windows.Messaging.MessageThread(true);
thread.Invoke(m => { window = new Tsukikage.Windows.Messaging.MessageWindow(); });
const int WM_APP_MEDIA_EVENT = 0x8001;
window.MessageHandlers[WM_APP_MEDIA_EVENT] = m =>
{
int ev, p1, p2;
while (MediaEventEx.GetEvent(out ev, out p1, out p2, 0) == 0)
{
if (ev == 0x01 && MediaComplete != null)
{
MediaComplete(this, EventArgs.Empty);
}
MediaEventEx.FreeEventParams(ev, p1, p2);
}
};
MediaEventEx.SetNotifyWindow(window.Handle, WM_APP_MEDIA_EVENT, 0);
BuildGraph(path);
if (RegisterToROT)
{
RotEntry = new RunningObjectTableEntry(GraphBuilder, "FilterGraph");
}
MediaControl.Stop();
}
public void Release()
{
if (GraphBuilder != null)
{
MediaControl.Stop();
ReleaseGraph();
MediaEventEx.SetNotifyWindow(IntPtr.Zero, 0, 0);
window.Dispose(); window = null;
thread.Dispose(); thread = null;
Marshal.ReleaseComObject(MediaControl); MediaControl = null;
Marshal.ReleaseComObject(MediaSeeking); MediaSeeking = null;
Marshal.ReleaseComObject(MediaEventEx); MediaEventEx = null;
Marshal.ReleaseComObject(MediaFilter); MediaFilter = null;
Marshal.ReleaseComObject(GraphBuilder); GraphBuilder = null;
}
if (RotEntry != null)
{
RotEntry.Revoke();
RotEntry = null;
}
}
/// <summary>
/// Stop the graph.
/// </summary>
public virtual void Stop()
{
LogMessage("Graph stopped");
reply = MediaControl.Stop();
DsError.ThrowExceptionForHR(reply);
}
/// <summary>
/// Invoked when the Pause command is executed
/// </summary>
/// <param name="sender">Sender</param>
private void DoRestart(object sender)
{
AutoRestart = true;
MediaControl.Stop();
Graph.Abort();
}
/// <summary>
/// Invoked when the Pause command is executed
/// </summary>
/// <param name="sender">Sender</param>
private void DoStop(object sender)
{
MediaControl.Stop();
Graph.Abort();
}
private static void ServerProcessReceived()
{
while (true)
{
var hp = _toProcess.Take();
switch (hp.Type)
{
case HarmonyPacket.PacketType.MouseMovePacket:
break;
case HarmonyPacket.PacketType.MousePacket:
break;
case HarmonyPacket.PacketType.KeyBoardPacket:
if (OnSlave == 0)
{
Keyboard.SendInput(hp.Pack);
}
else
{
SendAsync(hp);
}
break;
case HarmonyPacket.PacketType.DisplayPacket:
break;
case HarmonyPacket.PacketType.SaltPacket:
break;
case HarmonyPacket.PacketType.MediaControl:
switch (((HarmonyPacket.MediaControlPacket)hp.Pack).Action)
{
case HarmonyPacket.MediaControlPacket.MediaAction.PlayPause:
MediaControl.PlayPause();
break;
case HarmonyPacket.MediaControlPacket.MediaAction.Stop:
MediaControl.Stop();
break;
case HarmonyPacket.MediaControlPacket.MediaAction.SkipPrevious:
MediaControl.SkipPrevious();
break;
case HarmonyPacket.MediaControlPacket.MediaAction.SkipForward:
MediaControl.SkipForward();
break;
case HarmonyPacket.MediaControlPacket.MediaAction.Reload:
MediaControl.Reload();
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
