Informikon

I recently answered a couple of questions about audio files processing in .Net. I though I could write a short tutorial on using DirectShow Editing Services (DES) to append two wav files (which was one of the questions asked). Again a zip file with the code is provided.

We are not going to cover all the interfaces provided for editing services but we'll show a simple use of them by creating a timeline with a single track that plays the two wav files one after the other. In this way, you'll get an introduction to the basic objects of DES and how to use them in C#.

DES manipulate media files using the concept of a timeline. A timeline is a container for audio or video groups which themselves contain compositions and tracks. The tracks are the objects that contain our media files. In this tutorial, we'll construct a timeline with a single audio group and a single track; that track will contain our two wav files scheduled to play one after another.

First, let's start by bringing in the assembly that contains these interfaces. In VS, you can add a reference to the library qedit.dll, it will generate an assembly named "DexterLib" that we import into our program:

 
using DexterLib;
 
   

We'll also use the DirectShowLib from sourceforge for the other DirectShow interfaces. Then, we declare variables for the timeline object and its components:

        
// we'll have one timeline object
AMTimelineClass tl = null;
// with one group
IAMTimelineGroup tg = null;
// and one track
IAMTimelineTrack tt = null;
// and two sources
IAMTimelineSrc s1 = null, s2 = null;
 
   

As the comments describe, we have one timeline with one group and one track but two sources objects. Building the timeline is going to be done in the BuildTimeline method which start by creating a AMTimelineClass object, then add an audio group and a track:

                
// create our timeline object
tl = new AMTimelineClass();
// add one group and set the media type to audio (anything ! 0 )
IAMTimelineObj tlo4; 
tl.CreateEmptyNode( out tlo4, TIMELINE_MAJOR_TYPE.TIMELINE_MAJOR_TYPE_GROUP );
tg = (IAMTimelineGroup)tlo4;
tg.SetMediaTypeForVB( 1 );
tl.AddGroup( (IAMTimelineObj)tg );
// create a track and add it using VTrackInsBefore
IAMTimelineObj tlo1; 
tl.CreateEmptyNode( out tlo1 , TIMELINE_MAJOR_TYPE.TIMELINE_MAJOR_TYPE_TRACK );
tt = (IAMTimelineTrack)tlo1;
((IAMTimelineComp)tg).VTrackInsBefore( (IAMTimelineObj)tt, 0 );
 
   

You don't create groups, (compositions), tracks and sources by using the typical "new" keyword but by calling the method CreateEmptyNode with the corresponding type in this method second argument. For a group, we have to set its media type using the SetMediaTypeForVB method, which comes from the VB access to the qedit.dll.

Then we call AddGroup to add the group to the timeline. To add a track to the timeline, we have to go through the IAMTimelineComp interface to a composition object and call the method VTrackInsBefore which insert a track in the composition. In this code, we treat the group object as a kind of composition. The group, compostion and track distinctions are a bit arbitrary in my opinion, and the design of this part of the DES library sounds a little artificial.

Anyway, once we've added the group and track to our timeline. We need to create our two source objects:

                
// start preparing the 1st source
IAMTimelineObj tlo2; 
tl.CreateEmptyNode( out tlo2, TIMELINE_MAJOR_TYPE.TIMELINE_MAJOR_TYPE_SOURCE );
s1 = (IAMTimelineSrc)tlo2;            
// get the stream length and call SetStartStop (after proper conversion in units)
// the first source will be played at the beginning 
md = new MediaDetClass();
md.Filename = fName1;
md.CurrentStream = 0;            
double lengthD = md.StreamLength;
long length = (long)lengthD*10000000;
((IAMTimelineObj)s1).SetStartStop( 0, length );
s1.SetMediaName( fName1 );
s1.SetMediaTimes2( 0.0, lengthD );
// add the 1st source to the track
tt.SrcAdd( (IAMTimelineObj)s1 );
IAMTimelineObj tlo3; 
tl.CreateEmptyNode( out tlo3, TIMELINE_MAJOR_TYPE.TIMELINE_MAJOR_TYPE_SOURCE );
s2 = (IAMTimelineSrc)tlo3;                     
md = new MediaDetClass();
md.Filename = fName2;
md.CurrentStream = 0;            
double length2D = md.StreamLength;
long length2 = (long)length2D*10000000;
// we tack the 2nd source at the end of the 1st one
((IAMTimelineObj)s2).SetStartStop( length+1, length+length2+1 );
s2.SetMediaName( fName2 );
s2.SetMediaTimes2( 0.0, length2D );
// add the 2nd source
tt.SrcAdd( (IAMTimelineObj)s2 );
 
   

The code for the two sources is similar. We create a source object with a call to CreateEmptyNode as before. Then, we use a MediaDet object to retrieve the stream length (we assume that the file contains only one audio stream) and multiply this value by 1000000 since the source object method SetStartStop required a long argument which represents 100 nanoseconds unit. The call to SetStartStop for the second source use the length and length+length2+1 as start and stop time. This is how we set our timeline to play one file after the other. Then, we add the source to the track by calling the SrcAdd method. Once, we have created our timeline, we are ready to create our RenderEngine object:

                
// create our render engine and set its timeline 
// then build the front end
re = new RenderEngineClass();
re.SetTimelineObject( tl );
re.ConnectFrontEnd();       
 
   

The graph filters that are built in DES are create by calling ConnectFrontEnd after setting its timeline object. This filter graph will have one output pin for every group in the timeline. Now, we'll build the "back end" of the filter graph by adding a file writer and a WAV Dest filter to it. But first, we need to access the filter graph created by our call to ConnectFrontEnd, this is done like this:

                
// get the filter graph, needed to connect the "back end"
DexterLib.IGraphBuilder dfg;
re.GetFilterGraph( out dfg );
// get the output pin of the front end
// and call BuildBackEnd to add the filters
DexterLib.IPin outPin;
re.GetGroupOutputPin( 0, out outPin );
if( outPin != null ) 
{
    BuildBackEnd();
    // let DirectShow connects the front and back
    gb.Render( (DirectShowLib.IPin)outPin );                    
}
 
   

We call GetFilterGraph and GetGroupOutputPin then call BuildBackEnd and use Intelligent Connect to build the rest of the filter graph from the RenderEngine's outpin pin. BuildBackEnd just add two filters to the graph:

                
FileWriter file_writer = new FileWriter();
IFileSinkFilter fs = (IFileSinkFilter)file_writer;
fs.SetFileName( GenOutputName(), null );
// the guid is the one from the WAV Dest sample in the SDK
Type type = Type.GetTypeFromCLSID( 
              new Guid("3C78B8E2-6C4D-11d1-ADE2-0000F8754B99") );
object wavedest = Activator.CreateInstance( type );
// add the two filters to the back end
gb.AddFilter( (DirectShowLib.IBaseFilter)file_writer, "File Writer" );
gb.AddFilter( (DirectShowLib.IBaseFilter)wavedest, "WAV Dest" );
 
   

We create a FileWriter filter and access its IFileSinkFilter interface to set its name. Then we create a WAV Dest filter, which you need to compile and install (WAV Dest is a filter in the Samples directory of the SDK). After that, the call to Render with the front end output pin connects the necessary pins. We are left to issue the Run command on the MediaControl object to write the file to disk.

That's it. We have appended two wav files using the DirectShow Editing Services with C#. We've looked at timeline, group, track and source objects. And use the RenderEngine to create a filter group that could be connected to any desired "back end".

---

Bookmark it...