Informikon

Should we buy this answer like it would be "words from the Gospels"? I like the motto "trust but verify". One thing is sure, when we create a GraphBuilder object and run a stream through it, we end up creating a lot of threads and mixing native COM and managed code might not be an ideal mix for people who don't want to work more than what they have to get the job done.

So, we're not going to write filters in C#. But DirectShow client applications are an interesting possibility. The SDK already contains samples written in VB and there is no reason why we couldn't write similar applications in C#. So how do we go about it. There are a few samples at www.codeproject.com that use C# and DirectShow.

The easiest way to write a DirectShow client application is simply to wrap the library "quartz.dll" (with the tool tlbimp from the .Net SDK or by adding a reference to in a VS project). That's the easiest way but the methods we'd like might not be exposed this way. So we have a couple of alternatives. There a library called "FSFWrap.dll" that adds some of the missing APIs or we can look at DShowNet (available on the CodeProject web site).

Playing a file using DirectShow in C++ is illustrated in the SDK documentation as:

 
#include <dshow.h>
void main(void)
{
    IGraphBuilder *pGraph = NULL;
    IMediaControl *pControl = NULL;
    IMediaEvent   *pEvent = NULL;
    // Initialize the COM library.
    HRESULT hr = CoInitialize(NULL);
    if (FAILED(hr))
    {
        printf("ERROR - Could not initialize COM library");
        return;
    }
    // Create the filter graph manager and query for interfaces.
    hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, 
                        IID_IGraphBuilder, (void **)&pGraph);
    if (FAILED(hr))
    {
        printf("ERROR - Could not create the Filter Graph Manager.");
        return;
    }
    hr = pGraph->QueryInterface(IID_IMediaControl, (void **)&pControl);
    hr = pGraph->QueryInterface(IID_IMediaEvent, (void **)&pEvent);
    // Build the graph. IMPORTANT: Change this string to a file on your system.
    hr = pGraph->RenderFile(L"C:\\Example.avi", NULL);
    if (SUCCEEDED(hr))
    {
        // Run the graph.
        hr = pControl->Run();
        if (SUCCEEDED(hr))
        {
            // Wait for completion.
            long evCode;
            pEvent->WaitForCompletion(INFINITE, &evCode);
            // Note: Do not use INFINITE in a real application, because it
            // can block indefinitely.
        }
    }
    pControl->Release();
    pEvent->Release();
    pGraph->Release();
    CoUninitialize();
}
 
   

Here's is the equivalent code in C# using interop and quartz.dll:

 
using System;
using QuartzTypeLib;
class PlayFile {
  public static void Main( string [] args ) {    
    FilgraphManagerClass graphClass = null;
  try {
    graphClass = new FilgraphManagerClass();
    graphClass.RenderFile( args[0] );
    graphClass.Run();
    int evCode;
    graphClass.WaitForCompletion( -1, out evCode );
  } catch( Exception ) {}
  finally {
    graphClass = null;
  }  
  }
}
 
   

We declare the namespace QuartzTypeLib and we reference it on the command line (the command line to compile this program is: csc /r:Interop.QuartzTypeLib.dll PlayFile.cs). We passed the file name to play on the command line instead of hardcoding the name in the source as the example from the SDK. Also the first argument to WaitForCompletion is -1 because INFINITE is defined as 0xfffffff.

The interop version uses the FilgraphManagerClass to do all the work.

.Net Master (at CodeProject) decided that the COM interfaces for DirectShow are sufficiantly simple to write wrappers for them using the IDL provided with the SDK. The advantage of this approach is that you have more control on which members of the interfaces that you can access. The disadvantages are the code can be rather ugly and you have to think in term of native COM and managed code at the same time. Here is a C# version using DShowNet from .Net Master at CodeProject:

 
using System;
using System.Runtime.InteropServices;
using DShowNET;
class PlayFile {
  public static void Main( string [] args ) {
    IGraphBuilder graphBuilder = null;
    IMediaControl mediaCtrl = null;
    IMediaEvent mediaEvt = null;
    
    Type comtype = null;
    object comobj = null;
    try {
    comtype = Type.GetTypeFromCLSID( Clsid.FilterGraph );
    comobj = Activator.CreateInstance( comtype );
    graphBuilder = (IGraphBuilder) comobj; comobj = null;
    
    mediaCtrl = (IMediaControl)  graphBuilder;
    mediaEvt = (IMediaEvent)  graphBuilder;
    graphBuilder.RenderFile( args[0], null );
    mediaCtrl.Run();
    int evCode;
    mediaEvt.WaitForCompletion( -1, out evCode );
    }
    catch(Exception) {}
    finally {
      if( comobj != null )
Marshal.ReleaseComObject( comobj ); 
      comobj = null;
      mediaCtrl = null;
      mediaEvt = null;
      graphBuilder = null;
    }
  }
}
 
   

The call to GetTypeFromCLSID of the Type class, the call to CreateInstance of the Activator class and ReleaseComOjbect of the Marshall class are examples of what I meant by having to keep track of native COM and managed code. If the DShowNet implementation give you access to what you need but not the plain Quartz interop. Then DShowNet is the way to go.

At the moment, there is a Beta version of an open source extension to the DShowNet library. When the final version will be released, we'll look at the possibility to update our code using this new library.

We'll stop here for our first look at DirectShow and C#.

---

Bookmark it...