Informikon

In this tutorial, we'll implement a version of the JukeBox sample from DirectShow. I have simulated the sample GUI (to some extent) and I looked at the code only when I needed to know how to accomplish a certain task.   

The sample will use a form, a groupbox with buttons and a trackbar on the top. Then a listbox on the left, with a panel to hold the video window to its right. At the bottom of the form, we find a button to set the directory and another button to launch the GraphEdit application.

For this version, we haven't provided any pin info GUIs component and it doesn't have a mute button. We have used the quartz.dll as wrapped by VS and we have used the implementation of the Genghis group for the FolderNameDialog. We have provided a zip file which contains the source code for this sample plus a VS project file and a command script to compile the code (if you don't have VS). We have included a dll for the Genghis code since their license doesn't allow us to distribute their work in source form.

With these preliminaries out of the way, let's look at some code:

        
FilgraphManagerClass graphBuilder = null;
IMediaControl mediaCtrl = null;
IMediaEventEx mediaEvt = null;
IVideoWindow videoWin = null;
 
   

We have declared the graphBuilder object and three interfaces that we'll need. For every files that we'll play, we'll have to call:

        
void InitInterfaces() 
 {
    try 
    {   
        graphBuilder = new  FilgraphManagerClass(); 
        mediaCtrl = (IMediaControl)  graphBuilder;
        mediaEvt = (IMediaEventEx)  graphBuilder;    
    }
    catch(Exception) 
    {
        MessageBox.Show( "Couldn't start" );
    }
}  
void CloseInterfaces() 
{   
    if( mediaCtrl != null ) 
    {
        mediaCtrl.StopWhenReady();
        mediaEvt.SetNotifyWindow( 0, WM_GRAPHNOTIFY, 0 ); 
    }  
    mediaCtrl = null;
    mediaEvt = null;
    videoWin = null;
    graphBuilder = null;
}   
 
   

The InitInterfaces calls create the graphBuilder object and the needed interfaces. While the CloseInterfaces calls stop the graph and we cancel event notification as required by the IMediaEventEx interface (the doc says "Before you release the IMediaEventEx pointer, cancel event notification by calling SetNotifyWindow with a NULL window handle").

When we want to play a file we call:(where fName is the file name)

 
graphBuilder.RenderFile( fName );
 
   

Followed by:

                
  isSeeking = (graphBuilder.CanSeekForward() == -1) && 
      (graphBuilder.CanSeekBackward() == -1 );
  if( isSeeking )
      trackBar1.Enabled = true;
  else
      trackBar1.Enabled = false;
  ...
  videoWin    = graphBuilder as IVideoWindow;
  videoWin.Owner = (int)panel1.Handle;
  videoWin.WindowStyle = WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;                
  Rectangle rc = panel1.ClientRectangle;
  videoWin.SetWindowPosition( 0, 0, rc.Right, rc.Bottom );
  mediaEvt.SetNotifyWindow( (int)this.Handle, WM_GRAPHNOTIFY, 0 );                
 
   

graphBuilder.CanSeekForward returns OATRUE to indicate that the graph can seek forward. OATRUE is defined as -1 in dshow.h. We use the value of CanSeekForward and CanSeekBackward to decide to enable or not enable the trackbar.

Then we set the video window owner to the panel handle with the proper window style and the the window position to occupy the whole panel. We, then, tell the filter graph to sent event notifications to the form window as WM_GRAPHNOTIFY messages. When we do this, the DirectShow runtime will stuff WM_GRAPHNOTIFY messages in our main window message queue. To handle these messages we have to override the method Control.WndProc as follow:

        
 protected override void WndProc( ref Message m )
 {
     if( m.Msg == WM_GRAPHNOTIFY )
     {
         if( mediaEvt != null )
             OnGraphNotify();
         return;
     }
     base.WndProc( ref m );
 }
 
   

The interesting part is the call to OnGraphNotify. This method is implemented as:

        
void OnGraphNotify()
{
    int p1, p2;
    int code;
    try 
    {
        do
        {
            if( mediaEvt == null )
                return;    
            mediaEvt.GetEvent( out code, out p1, out p2, 0 );   
            mediaEvt.FreeEventParams( code, p1, p2 );
            if( code == EC_COMPLETE )
                OnClipCompleted();
        }
        while( true );
    } 
    catch( Exception ){}
}
 
   

This is the C# translation of the C++ code given in the DirectShow documentation (see the sections entitled "Responding to events" and "Learning when an event occurs"). The main difference between this code and the one in the SDK is that we wait for GetEvent to throw an exception to get out of the loop. The "native" GetEvent returns an HRESULT value (i.e. E_ABORT) which get translated to an exception by the interop layer. OnClipCompleted just updates some properties maintained by the GUI controls in the application.

The rest of the code is just a collection of event handlers for the controls of this application. We'll point out the timer that we added to display the current position beside the trackbar. The timer object generates Tick events that we use to update the position label. But we also use it to set a flag isTimer so we don't have to handle the TrackBar.ValueChanged event too often (since this handler seeks the filter graph).

---

Bookmark it...