A command line cam image grabber

EDIT (20-11-2011) : Since posting this, I have created a new DirectShow command line image grabber called CommandCam, which I recommend you use instead of this one. It’s also completely free. Get CommandCam here (binary download and source code available).

Earlier today, I was looking for a command line image grabber for Windows to use with a webcam in a batch file. To my amazement, I simply could not find one that worked for me, so I’ve hacked together my own simple one in C using Microsoft’s venerable Video for Windows (VFW) API. Of course, there’s probably a “better” way of doing this, but this program is at least reasonably concise and to the point – basically, it’s what I needed. Thankfully, it’s much shorter than any of the video capture programs I ever wrote using DirectShow. The error checking is rudimentary to say the least – you might get an error message if something goes wrong.

Acknowledgement: My Win32 programming was never very good, but it’s extremely rusty right now, so theForger’s Win32 API Tutorial proved absolutely indispensible when I was writing this program. It’s a wonderful resource and is definitely my favourite Win32 programming guide – many thanks to theForger!

Here’s the executable file:

snapz.exe (24KB, date: 5-4-2011)

To use it, open a command window, move to the directory where snapz.exe is saved and simply type snapz. The program will open the default video capture device (e.g. a webcam) and grab a single snapshot at 640×480 resolution. The image will be saved to a device independent bitmap (DIB) file called snapz.dib in the same directory. This file format is uncompressed, so the file will be almost 1MB in size. You can convert it to a different format using another graphics program if you wish. I’m planning to use ImageMagick for that purpose in the batch file I’ll be using snapz in.

Here’s a screenshot of my command window. Note that the file snapz.dib appeared in the directory when I ran snapz.exe.

Here’s the image it captured (my arm, kettle, toaster):

Here’s the snapz code:

snapz.c (4KB, date: 5-4-2011)

I compiled it using gcc (MinGW version 5.1.4). The command to compile it is:

gcc -o snapz.exe snapz.c -lvfw32

If this turns out to be useful to you, please leave a comment to let me know.

Here’s the complete code:

//
// snapz.exe - a command line cam image grabber
// Written by Ted Burke, Last updated 5-4-2011
// ted.burke@dit.ie, batchloaf.wordpress.com
//
// To compile with MinGW:
//	gcc -o snapz.exe snapz.c -lvfw32
//

#include <windows.h>
#include <vfw.h>
#include <stdio.h>

// Window handles
HWND hWnd;
HWND hWndCap;

int capture_w = 640;
int capture_h = 480;
int capture_device = 0;	// default capture device
int time_delay = 0;	// delay in ms before snapshot
int preview_video = 0;	// Don't show on screen

// Message handling function
LRESULT CALLBACK WndProc(
    HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
    case WM_TIMER:
        // Save DIB snapshot, then exit from program
        capGrabFrame(hWndCap);
        capFileSaveDIB (hWndCap, "snapz.dib");
        DestroyWindow(hWnd);
        break;
    case WM_CLOSE:
        DestroyWindow(hWnd);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, msg, wParam, lParam);
    }
    return 0;
}

int WINAPI WinMain(
    HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
{
    // Register window class
    WNDCLASSEX wc;
    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style         = 0;
    wc.lpfnWndProc   = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance     = hInstance;
    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = "snapzWindowClass";
    wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);
    if(!RegisterClassEx(&wc))
        fprintf(stderr, "Window Registration Failed!");

    // Create main window
    hWnd = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "snapzWindowClass",
        "snapz",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        capture_w + 100, capture_h + 100,
        NULL, NULL, hInstance, NULL);
    if (hWnd == NULL)
        fprintf(stderr, "Couldn't create main window.");

    // Create capture window
    hWndCap = capCreateCaptureWindow(
        NULL, WS_CHILD,
        0, 0, capture_w, capture_h,
        hWnd, 0);
    if (hWndCap == NULL)
        fprintf(stderr, "Couldn't create capture window.");

    // Connect to capture driver and set resolution
    capDriverConnect(hWndCap, capture_device);
    DWORD dwSize = capGetVideoFormatSize(hWndCap);
    LPBITMAPINFO lpbi = (LPBITMAPINFO)malloc(dwSize);
    capGetVideoFormat(hWndCap, lpbi, dwSize);
    lpbi->bmiHeader.biWidth = capture_w;
    lpbi->bmiHeader.biHeight = capture_h;
    capSetVideoFormat(hWndCap, lpbi, dwSize);
    free(lpbi);

    // Initialise and start video preview
    if (preview_video > 0)
    {
        // Set up video preview
        capPreviewRate(hWndCap, 1); // rate in ms
        capPreview(hWndCap, TRUE);
        ShowWindow(hWndCap, SW_SHOW);

        //Show main window
        ShowWindow(hWnd, nCmdShow);
        UpdateWindow(hWnd);
    }

    // Set timer to trigger snapshot
    SetTimer(hWnd, 1, time_delay, NULL);

    // Message loop
    MSG msg;
    while(GetMessage(&msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    // Tidy up video capture stuff
    KillTimer(hWnd, 1);
    capPreview(hWndCap, FALSE);
    capDriverDisconnect(hWndCap);
    if (hWndCap) DestroyWindow(hWndCap);

    return msg.wParam;
}