VB6 - DirectShow WebCam Minimal Code

[dilettante]

There are a number of possible APIs in Windows for previewing and capturing from webcams. One of the most popular for its broad support on Windows versions and its relative ease of use when requirements are simple is the AviCap/Video for Windows API.

But a downside of VfW is that the driver model Windows uses to support video capture devices changed after the end of 16-bit Windows (Win3.1, etc.). This means several things, but most commonly frustrating is that instead of mapping multiple webcams as device 1, 2, ... 9 they work through a compatibility layer thats maps one of them as device 1.

This can make selecting the webcam to use difficult to impractical. And using more than one webcam at a time doesn't seem possible.

The usual answer has been: "Use DirectShow instead of VfW."


DirectShow vs. VB6

One problem with using DirectShow is that Microsoft seemed to have lost enthusiasm after providing only a partial implementation. The parts of DirectShow (also called ActiveMovie) we did get a VB6-friendly API for are implemented in the Quartz.dll which should be part of Windows in any recent version (and perhaps even back to most "late" Windows 95 versions like 95B or OSR2.x).

You can still do a lot of things using just what we have, but the finer points of using DirectShow in VB6 require a 3rd party DLL to wrap a few more DirectShow C++ interfaces.


This "Minimal Approach" to VB6, DirectShow, and WebCams

What I have done here is to try to stretch things as far as I could manage.

Here is what you can do:

• Choose among your webcams and display a live preview image.
• "Snap" and display a still image from the webcam feed.

Here is what you can't do:

• Get a "friendly" list of just the usable webcams.
• Control the capture resolution/dimensions or other capture settings or even raise the built-in dialogs to let the user do so.

The Demo

What I wanted to accomplish was to see how far I could get with the two tasks we can perform without using any 3rd party libraries.


Form1

This is the main UI Form, which uses Form2 as a dialog when requested via its menu ("Add new camera...").

There is a lot more code there than I'd like that does nothing except manage the menu. As you add cameras they are added to the menu. There is also code there to load and save "settings" which include the index of the selected camera and list of added cameras by name.

Basically a lot of UI-management code which I hope doesn't obscure the DirectShow-related logic itself.

The other ugly hunk of code in there is the BuildGraph() function, which is a small interpreter of a sort that processes a "filter script" and a "connection script" to add the necessary filters and connect them to create a webcam preview graph for DirectShow.


Form2

Since I can't find any way to find just the list of usuable webcams, the user has to pick them out from among the full list of available "filters" (as they are called)! Not practical at all for a real application, but it works for a test/demo program.

That's what Form2 in the demo Project is for, a dialog from which to pick new cameras.

Note that your camera might appear there once, twice, or even three or more times depending on how many "filters" of different kinds it supports. Just pick any of them, the demo program will just use the name and sort it out later.


Module1

This contains some GDI and OLE API calls to convert the captured frame from a "packed DIB" into a StdPicture object that can be used with PaintPicture, etc. This raw StdPicture is created using a "memory DC" so there are some limits on how you can use it, i.e. simply assigning it to a PictureBox.Picture has some issues.

But in this demo we need to scale it anyway since we can't control the actual capture dimensions.

You could rework this passing in the hDC of a Form, PictureBox etc. I suppose.


Running the DSMini1 Project

The attached ZIP archive contains the entire Project.

All you should need to do is unzip the archive, then open the Project in VB6. If you have a webcam connected, you can just go ahead and run it within the IDE.

From there you will have to "Add" your webcam by browsing the filter list.

After a valid add, the live preview starts immediately at the left.

Clicking on the Snap button should take a snapshot and display it in the PictureBox at the right.

If you have another webcam connectd you shuld be able to add that one too. Once you have two or more added you can choose among them via Form1's menu.

Settings are persisted in Settings.txt, so a subsequent run should save you the trouble of picking cameras again.


Remarks

I don't know what webcams this will work with, but I know it works with two very different ones I've tried so far.

[dilettante]

To show that you can use these techniques to run multiple webcams, I give you DSMini2.

The menus are rearranged, the settings file contents are slightly different, and the snapshot function has been pulled out, but now if you have multiple webcams you can preview two at once. Pretty much all of the other comments about running DSMini1 apply to DSMini2.


One thing not mentioned about DSMini1 is that it scales the views to fit the camera's aspect ratio. The same applies in DSMini2, but it might be more noticeable if your webcams have different aspect ratio settings: one view will be "shorter" than the other one.

[dilettante]

A little refinement. Mainly small bug fixes in Form menu handling, a tweak to the logic for creating a StdPicture snapshot, etc.

Big change: Replaced a bunch of inline DirectShow related code in Form1.frm by a new DSPreview.ctl UserControl.


DSMini3 is the improved version of the single cam/snapshot demo (DSMini1).

DSMini4 is the improved version of the dual-cam demo (DSMini2).

[dilettante]

Hmm, DSMini3 has a small flaw.

When you select a camera to preview that has a different aspect ratio from the default one it expects, it fails to adjust the "snapshot" PictureBox. The result is some stretching or squishing of the snapshot.

Not a big deal but something to consider. If you need to deal with it I'm sure you can on your own. Not worth reposting an update I suppose. DSMini1 was handling this issue properly though.

[ColinE66]

I don't have a webcam attached to my PC but, nonetheless, I lifted some of your code into a VB6 project of my own as I was interested in your GetCurrentImage implementation. It does indeed work very well but is, however, a lot (noticably!) slower than using the SampleGrabber approach.

Is this because of your over-generosity of the buffer size or is it just intrinsically slower?

[ravemaster]

yes I have checked it but i only give me black picturebox, no image at all, only black. that is why I wonder why that ocx is having no problem except that it has no save to file or to db capability.

attach is the screenshot of the result

[dilettante]

I don't have a webcam attached to my PC but, nonetheless, I lifted some of your code into a VB6 project of my own as I was interested in your GetCurrentImage implementation. It does indeed work very well but is, however, a lot (noticably!) slower than using the SampleGrabber approach.

Is this because of your over-generosity of the buffer size or is it just intrinsically slower?

SampleGrabber works without pausing the filter graph, but GetCurrentImage requires that. However I don't know of any way to use SampleGrabber in a VB6 program without additional helper DLLs, so GetCurrentImage is useful in "first steps" examples of working DirectShow programs.

[dilettante]

yes I have checked it but i only give me black picturebox, no image at all, only black.

Could be lots of things. Might be that your webcam has default settings leading to a black picture. Or it might be that the filter graph I am building doesn't work with your camera. This is where you would need to experiement since there may not be a universal solution.

Start by working with the graphedt.exe utility from the DirectShow (now part of the Windows) SDK.

What camera do you have?

that is why I wonder why that ocx is having no problem except that it has no save to file or to db capability.

Ocx? What ocx?

Save to file or DB? This is a code sample. If you want a full blown program for some purpose you can add more code or hire a programmer. This is CodeBank, not UtilityBank.

Plus at this point saving the image isn't too useful. First you need control over the capture format or risk getting nothing but tiny low-res images. This kind of control also requires a 3rd party helper DLL.

[dilettante]

Ok, here is a more elaborate example DSElaborate5, based on DSMini1 & DSMini3 (one camera, with snapshot capture).


Background Info

I have not found a way to get these features without a helper DLL that can wrap a few more DirectShow interfaces in "Automation" (ActiveX) form.

I decided to use what appears to be the widely used FSFWrap.dll from Geraint Davies Consulting Ltd. (GDCL). I says appears to be widely used, because oddly enough some heavy searching of the Web didn't turn up a single useful example of the use of this library. All I found was an example from GDCL that doesn't seems to work with cam-capture, and somebody's attempt to convert that same VB6 example to VB.Net 2XXX (not sure which VB.Net, don't care).

My conclusion:

This was never that popular, or it used to be and a lot of posted examples have disappeared since 2005 or so, or it is quite popular but most users are too lazy or greedy to share by posting helpful information and working code...

... or I'm just not that great at searching.


This New Example

In order to run this example yourself you will have to obtain and install this library. I'm attaching the instructions along with a .DEP file that the author failed to provide for the library. I can't provide the DLL, because (a.) we aren't supposed to attach binaries and (b.) it isn't mine to hand out.

So here are the new features:

• Camera selection dialog is now built selectively, i.e. it should list your cameras and only your cameras.
• Capture (pin) properties can be viewed and altered when a camera is started.
• Camera (filter) properties can be viewed and altered once a camera has been started, and these changes are "live."

I can't find a way to make the pin properties pages work properly except as part of building the filter graph and starting it. Perhaps somebody else has an alternative that allows changes to these while the graph is running.


Since I now have a way to configure the pin properties (mainly the capture dimensions) I have added an unrelated feature:

• Both Snap and Snap+Save (to JPEG file) buttons are present.

And "Snap to Byte array" could be added. The code is there, you just need Edanmo's olelib.tlb for that. See the new GPP2J.cls module's header comments for details.


I hope you find this new version interesting, if not useful.

[dilettante]

SampleGrabber works without pausing the filter graph, but GetCurrentImage requires that. However I don't know of any way to use SampleGrabber in a VB6 program without additional helper DLLs, so GetCurrentImage is useful in "first steps" examples of working DirectShow programs.

Ok, so that's what the docs say.

But I found somebody skipping the pause yet doing GetCurrentImage() calls... so I tried it and things are working just fine!

[dilettante]

Ok, one more time...

This version is the same as 5b above, but with a change to the filter graph and method by which the graph is connected. All told just a few lines difference.

It might address the "black picture" problem though.


ffdshow

It is also worth noting that if you have ffdshow installed, a dialog from it may appear when testing in the IDE and again for the compiled EXE. It seems to maintain a "blacklist" or something though, so you can choose "don't show this again for this program" and you won't be bothered again.

Of course you'll get that both for VB6.EXE (runs in the IDE) and the compiled program, separately. And you can always opt to be reminded each time instead if this matters to you.

[ColinE66]

I actually use capstill.dll in my program (link in sig) and I do recall seeing some code at his site for working with webcams but, if memory serves, it accompanied his fsfwrap.dll - you might want to take a look at that.

EDIT; sorry for confusion if you happened to read the pre-edit version of my post; capstill.dll is the one that facilitates the SampleGrabber, not fsfwrap.dll. Within one of the demo projects (can't remember if it was capstill or fsfwrap) I recall seeing some code related to webcams.

[dilettante]

I still have to get around to looking at the Sample Grabber. I see that it is a deprecated filter with Merit set to MERIT_DO_NOT_USE, but what isn't deprecated by Microsoft these days?


The point of this thread was to try to demystify the use of DirectShow webcam capture in VB6. I'm not sure that this can be done once you start requiring extra helper DLLs.

My examples 3 and 4 above are refinements of 1 and 2 and don't introduce anything complex. They also get results as good or better than what most people are doing with the older VfW API anyway.

What 1 through 4 lack is the ability to set the most minimal capture params, such as the capture image size. While my several stabs at example 5 address this, it is indirect (i.e. via the properties dialogs).


So all I really care about beyond this is setting those within the program itself, in code instead of through dialogs. Well, that and trying to figure out where the "black picture" problem comes from for some cameras or users and fixing that if possible.

[ColinE66]

OK. I was just trying to help as earlier you said this:

I decided to use what appears to be the widely used FSFWrap.dll from Geraint Davies Consulting Ltd. (GDCL). I says appears to be widely used, because oddly enough some heavy searching of the Web didn't turn up a single useful example of the use of this library. All I found was an example from GDCL that doesn't seems to work with cam-capture, and somebody's attempt to convert that same VB6 example to VB.Net 2XXX (not sure which VB.Net, don't care).

My conclusion:

This was never that popular, or it used to be and a lot of posted examples have disappeared since 2005 or so, or it is quite popular but most users are too lazy or greedy to share by posting helpful information and working code...

... or I'm just not that great at searching.

[dilettante]

Thanks, I missed your link. I normally have signatures turned off since so many are huge blobs of images and other distractions.

[dilettante]

I tried 5b with a laptop having a camera identifying itself as Chicony USB 2.0 Camera and it works there too.

One quirk I did see was that if I changed the capture dimensions from those it defaults to (which are never the dimensions marked "(default)" in the properties dialog???)... the image can come up very dark.

But with this dark image, if I then choose the Configure camera properties... dialog and once that pops up I click on the Default button there... the camera seems to automatically adjust the exposure to something usable.

I'm not saying this is the root of the "black picture" issue, but it did seem odd.

[sambra22]

hi
first thank you a lot for the app it helped me a lot
i added it to my project
i still new to programming i have 5 month now
my only problem is :
is there a way to filter the list items to show only the camera drivers because there is a lot drivers shown
thanks for help

[dilettante]

To limit the list of filters to capture filters (cameras) you need to use a 3rd party helper library. That is because the necessary interfaces to do this in VB6 were not provided by Microsoft.

See post #9 and later for examples of this, using the popular helper library FSFWrap (free). Those are the "Elaborate" examples: 5a, 5b, and 5c.

[sambra22]

hi Mr delettante :
thank you a lot for the help
i did it it works great thanks a lot so much

[sambra22]

hi delettante
i need an advice from you if possible
how i can learn how to use any library file
for example i want to learn how to use twain32.dll or FSFwrap.dll
or any other dll file what is the best way thanks

[dilettante]

You need to get the DLL's documentation.

For FSFWrap there isn't much that I can find except what its author posted years ago. So to use it you have the few hints there, his sample programs there, what you can work out using the Object Browser in the VB6 IDE, and what you can guess based on the C++ interfaces documented in the MSDN Library.

As far as I can tell not many people ever did much with FSFWrap, or if they did they never wrote much about it that I could find on the Web.

Documentation can be as hard to create (or harder) than writing the code itself. So many free libraries don't have much.

The TWAIN API is very old (though still popular). But because it is old it can be very hard to find any Microsoft documentation for it now, plus it is "owned" by http://www.twain.org/ so you might try there.

[sambra22]

hi
so to learn how to use any library i have to get its documentation because its always seems for me that the codes is hard to learn and understand
thank you for your advice
thanks a lot

[ladoo]

xxxxxxxxxxxxxxxxxxxxxxxxxxx

[dilettante]

What you have posted is an example of using AviCap in the most simplistic fashion possible.

I see you have edited this out of post #23 now.

This is extremely common and there are quite a few CodeBank examples already posted. Your program also makes use of the clipboard in way that programs never should when at all possible. There are far better AviCap examples here in the CodeBank that do not destroy the user's clipboard data.

And your attachment has nothing to do with using DirectShow from VB, which is what this thread is all about.


The reason to try to use DirectShow instead of AviCap is that it offers your program much more control over capture formats and camera settings, allows selection among multiple cameras, capture from more than one camera at a time, and offers other potential advantages.

That's why this thread is here: to help people start programming using DirectShow instead of the old AviCap API.

[ladoo]

system is overheating...............................................cool down

[SpaceDonkey]

Hello,

First, thanks for this thread.

I tried 5C but no luck, I keep getting 'BlueGraph error' , tried with several webcams. (Win8 x64 btw)

[Mike Scott]

downloaded the DSMini4.zip and find it works great with a USB cam, but not with a video to USB adapter.
In this event, the EasyCap adapter. It sees the cam as 'SMI grabber device' (which works as I can see the pic in other apps), but when I try preview I get-
----------------------------------
Selected camera for preview 0 failed, may not be connected
SMI grabber device
BuildGraph error 1
----------------------------------

Any suggestions?

[dilettante]

I tried 5C but no luck, I keep getting 'BlueGraph error' , tried with several webcams. (Win8 x64 btw)

downloaded the DSMini4.zip and find it works great with a USB cam, but not with a video to USB adapter. In this event, the EasyCap adapter.

Any suggestions?

I don't have a Win8 test system set up but I would expect it to work there with no problems.

However these programs are only able to handle some generic cases so finding webcams that won't work is very likely. These sample programs are probably best treated as examples of how you can use DirectShow in VB6 programs.

DirectShow covers a large set of multimedia operations through "building blocks" and your programs need to "assemble" several blocks together to "spell a word" (to stretch an alphabet-block analogy). These programs are making assumptions about the "block" at the beginning and the "block" at the end and try to assemble the necessary "blocks" to span the gap between them.

It is a little more complicated even than that makes it sound. Every "block" can have zero to many inputs and zero to many outputs, and your program needs to string the blocks together by joining the right outputs to the right inputs.

Your capture device (camera) may not have the particular output "pin" as they're called that my programs here expect. Or it might have the right output pin, but it may require another intermediate filter block to transform its output data stream.


To handle things truly generically (to write a "universal" program) you'll probably need to understand the process better than I do, you'll need more complicated code, and it may not even be possible in VB6 since only a few items are made available in a form easily used in VB6. The FSFShow wrapper helps, but may not make enough of DirectShow available to do the entire job.


If you have the Windows SDK you'll find that the old DirectShow SDK has been merged into it. This gives you a tool to play with called graphedt.exe ("GraphEdit"):

This might give you something to experiment with so you can improve what I have tried to do in these sample programs.

Of course translating from there to a VB6 program can be tricky, and it will require that you study the DirectShow documentation in some detail. But perhaps my sample programs and the FSFWrap author's samples will help get you there.

[Mike Scott]

I don't have a Win8 test system set up but I would expect it to work there with no problems.

However these programs are only able to handle some generic cases so finding webcams that won't work is very likely. These sample programs are probably best treated as examples of how you can use DirectShow in VB6 programs.

DirectShow covers a large set of multimedia operations through "building blocks" and your programs need to "assemble" several blocks together to "spell a word" (to stretch an alphabet-block analogy). These programs are making assumptions about the "block" at the beginning and the "block" at the end and try to assemble the necessary "blocks" to span the gap between them.

It is a little more complicated even than that makes it sound. Every "block" can have zero to many inputs and zero to many outputs, and your program needs to string the blocks together by joining the right outputs to the right inputs.

Your capture device (camera) may not have the particular output "pin" as they're called that my programs here expect. Or it might have the right output pin, but it may require another intermediate filter block to transform its output data stream.


To handle things truly generically (to write a "universal" program) you'll probably need to understand the process better than I do, you'll need more complicated code, and it may not even be possible in VB6 since only a few items are made available in a form easily used in VB6. The FSFShow wrapper helps, but may not make enough of DirectShow available to do the entire job.


If you have the Windows SDK you'll find that the old DirectShow SDK has been merged into it. This gives you a tool to play with called graphedt.exe ("GraphEdit"):

This might give you something to experiment with so you can improve what I have tried to do in these sample programs.

Of course translating from there to a VB6 program can be tricky, and it will require that you study the DirectShow documentation in some detail. But perhaps my sample programs and the FSFWrap author's samples will help get you there.

Unfortunately, the SDK kit looks like it's for Win8 only. I'm on XP :-(

[dilettante]

Unfortunately, the SDK kit looks like it's for Win8 only. I'm on XP :-(

When you snooze you lose I guess. XP is dead and cold now with Vista on the chopping block next.

There should still be a Windows 7 SDK for a few months.

And you can still order old SDK CDs for a shipping fee from SDKs.


But as far as I know even the Win8 SDK download should install fine on an XP system. Just note that a lot of old stuff is gone and some of the new stuff won't run on XP.


Also note that your old MSDN Library CDs that VB6 uses for it online Help contain most of the C++ and VB6 DirectShow documentation that exists. The October 2001 issue is best, but any from shortly before then should be Ok too.