Let's don't get stuck here. I'll post some of my other "amazing"
findings here, still related to the subject. A single RCW object
representing the filter (IBaseFilter) is used by the first and second
thread. The request made by the first thread that returns such an
object is BindToMoniker, as the second thread, afterwards, gets the
same object through the call to enumFilters. So far so good. Let's
release the instance just after it gets added to the graph. We add the
line Marshal.ReleaseComObject(source) in the first thread, somewhere
after graphBuilder.AddFilter(source, "source"), but before signaling
the second thread to start. Surprise! The RemoveFilter works now, even
by removing the DoEvents line in the first thread!!! If the requests
made through IGraphBuilder get proxied through the first thread, WHY am
I allowed to do this? And why, now, RemoveFilter works?

   public void Thread1()
   {
       IFilterGraph filterGraph;
       int hr;

       DsDevice[] d =
DsDevice.GetDevicesOfCat(FilterCategory.VideoInputDevice);
       string monikerID = d[0].DevicePath;

       //set up main interfaces
       filterGraph = (IFilterGraph)new FilterGraph();
       graphBuilder = (IGraphBuilder)filterGraph;

       rotEntry = new DsROTEntry(filterGraph);

       //get the source filter
       IBaseFilter source =
(IBaseFilter)Marshal.BindToMoniker(monikerID);

       //add the filter
       hr=graphBuilder.AddFilter(source, "source");
       DsError.ThrowExceptionForHR(hr);
       Marshal.ReleaseComObject(source); //BIG SURPRISE HERE!

       //we finished working here, but keep the thread running
       finishThread1 = true;
       while (!finishThread2)
       {
                    Application.DoEvents();
       };
       rotEntry.Dispose();
   }

   public void Thread2()
   {
       int hr;
       //wait for the first thread to finish its work
       while (!finishThread1)
       {
           Thread.Sleep(100);
       }

       IEnumFilters enumFilters;
       hr=graphBuilder.EnumFilters(out enumFilters);
       IBaseFilter[] filters=new IBaseFilter[1];
       int fetched;
       do
       {
           hr=enumFilters.Next(1, filters, out fetched);
           if (fetched != 0)
           {
               hr = graphBuilder.RemoveFilter(filters[0]);
               //Application.DoEvents(); <- this doesn't make any
difference
           }
           enumFilters.Reset();
       } while (fetched != 0);
       finishThread2 = true;
   }

Doesn't matter, if your thread is initialized for STA it must pump the
message queue, otherwise it's not possible to marshal calls to another
apartment/thread.

Willy.

Willy, it does return 0 as an error code, but it does return. It's
really hard to keep focus on the matter with you guys :))))

Let's focus on the sample above. In the thread one we have these lines:
  while (!finishThread2)
       {
                    Application.DoEvents();
       };

In the second thread, one of the calls is
graphBuilder.RemoveFilter(filters[0]). And we all agreed I have to keep
pumping in the first thread in order for this call to work. How come
NOW (when I explictly release the COM object IBaseFilter), if i comment
the line Application.DoEvents(), the second thread won't freeze at the
RemoveFilter line?