Instead I disagree. A push model would be easier to
implement. See below.

Your source filter can be created in 2 ways and it's up to
you to decide:

1. you create it anyway you like and add it to the graph
yourself; this way you have a reference to the object and
you can do whatever you need with it

2. the filter graph adds it when it tries to render a custom
URL; this way you need to package the filter in its own COM
inproc server DLL, globally register it, register your
custom protocol and last you will need to enumerate the
filters in the graph to get a reference to it

If your filter is only used internally in your application,
#1 is a lot easier.

An alternative would be using UDP sockets: they are
message-based instead of stream-based, so that they would
preserve the sample boundaries without you implementing your
own framing, and as efficient (since they would be routed
over the virtual loopback device), but you would need to
implement your own inter-process security, if local security
is a concern (local meaning on the same machine, since total
security from the outside world would be provided the socket
itself).

Yes. You can do it in any number of ways depending on your
needs and how complex you want it to be, but this is the
easiest:

1. derive your filter class from CBaseFilter and your output
pin class from CBaseOutputPin

2. in your filter class, override GetPin() and GetPinCount()

3. in your output pin class override GetMediaType(),
CheckMediaType() and DecideBufferSize()

4. add a custom interface to your filter class that has a
single method you call to synchronously feed a data block to
the graph; this method calls GetDeliveryBuffer() on the
output pin, copies the data block to the sample and calls
Deliver() on the output pin

5. you may want to add a couple more methods to the custom
interface to set the number of output pins and their media
types

From the application point of view, pushing data through the
graph will be as simple as calling a normal synchronous
function in VideoForWindows style and the code required to
create filter and pins is less the 3 screenfuls in C++.

This works well unless you need asynchronous processing or
you need to connect to a parser/splitter, which will expect
an async reader upstream instead of a push source (but this
would be easy enough to accomplish as well).

--
// Alessandro Angeli
// MVP :: DirectShow / MediaFoundation
// a dot angeli at psynet dot net