ich beschäftige mich momentan mit dem Webcam Programm von http://www.cppb.allanpetersen.com/software.htm . Diese Programm arbeitet mit der WinAPI. Ich habe es schon so verändert, dass durch einen Timer alle 10sek ein Bild geschossen wird, was in einem anderen Programm weiterverarbeitet wird.

Leider bekomme ich es nicht hin, die Auflösung der Webcam zu ändern. Ich möchte diese fest auf 640x480 stellen. Die Webcam-Aufnahme startet jedoch immer auf 320x240. Meine Cam kann Auflösungen von 640x480 darstellen.

Ich arbeite mit dem Borland C++Builder

Auf Wunsch kann ich auch den Quelltext posten. Dieser ist jedoch noch fast wie auf der oben genannten Homepage vorhanden.

Durch Nachforschungen hier im Forum bin ich schon auf die capSetVideoFormat Funktion gestoßen. Diese wird in
http://www.c-plusplus.net/forum/viewtopic-var-t-is-116057-and-view-is-next.html
und
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/multimed/htm/_win32_capsetvideoformat.asp
beschrieben.

Leider bin ich neu in WinAPI und versteh leider nicht, was das für Argumente sind, die die Funktion braucht. Kann mir das bitte jemand erklären? Lese die Seiten jetzt schon seit Minuten durch und verstehe nur Bahnhof.

Hab mir im Netz ein bisschen was zusammengesucht und auf diese Weiße verwirklicht:

//Die Standarteinstellungen laden
DWORD dwSize;
BITMAPINFO *pbiInfo;

dwSize=capGetVideoFormatSize(hwndVideo);

capGetVideoFormat(hwndVideo, pbiInfo, dwSize);

// Einstellen der neuen Werte
DWORD dwWidth,dwHeight,dwBPP;
char *svWidth,*svHeight,*svBPP;

dwWidth=640;
dwHeight=480;
dwBPP=16;

pbiInfo->bmiHeader.biWidth = dwWidth;
pbiInfo->bmiHeader.biHeight = dwHeight;
pbiInfo->bmiHeader.biBitCount = (WORD) dwBPP;

pbiInfo->bmiHeader.biSizeImage = 0;
pbiInfo->bmiHeader.biCompression = BI_RGB;
pbiInfo->bmiHeader.biClrUsed = 0;
pbiInfo->bmiHeader.biClrImportant = 0;
pbiInfo->bmiHeader.biPlanes = 1;

pbiInfo->bmiColors->rgbBlue = 0;
pbiInfo->bmiColors->rgbGreen = 0;
pbiInfo->bmiColors->rgbRed = 0;
pbiInfo->bmiColors->rgbReserved = 0;

//Zurückschreiben zur API
capSetVideoFormat(hwndVideo, pbiInfo, dwSize);

Leider wird das Videofenster immernoch nur in der Auflösung 320x240 angezeigt. Ich dreh langsam durch.

Hat keiner Ahnung vom Ansprechen einer Webcam mit C++?

Remarks
Because video formats are device-specific, applications should check the return value from this function to determine if the format is accepted by the driver.

Schau mal nach, ob's überhaupt klappt.

Nach den Beträgen bin ich auch auf den Geschmack gekommen meine Webcam zu aktivieren. Könntest den SourceCode posten mit es geklappt hat.

Vielen Dank

Peter

Die Cpp-Datei

#include <vcl.h>
#pragma hdrstop

#include <stdio.h>
#include "c_cap.h"
#include "Unit6.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)

__fastcall TCap::TCap (HWND Handle)
{
        // create video capture window
        ParentHandle = Handle;
        hwndVideo = capCreateCaptureWindow(
                    (LPSTR) "My Capture Window",
                    WS_CHILD | WS_VISIBLE,
                    0, 0, 300, 200,
                    (HWND) Handle,
                    (int) 1);

        pStringCapDrivers = new TStringList;
        SelectedDevice = -1;
}

__fastcall TCap::~TCap ()
{

        delete pStringCapDrivers;

        capCaptureStop(hwndVideo);
        capPreview(hwndVideo, FALSE); // end preview
        capDriverConnect(hwndVideo, SelectedDevice);
        capDriverDisconnect(hwndVideo); // disconnect from driver
        capCaptureAbort(hwndVideo);
}

//---------------------------------------------------------------------------
// enumerate the installed capture drivers
//---------------------------------------------------------------------------
int TCap::EnumCapDrv ()
{
	char szDeviceName[80]; // driver name
	char szDeviceVersion[80]; // driver version
	char str[161]; // concatinated string
	int xcap; // counter

        xcap = 0;
        pStringCapDrivers->Clear ();
        do
        {
                if (capGetDriverDescription(xcap, szDeviceName, sizeof(szDeviceName),
                szDeviceVersion, sizeof(szDeviceVersion)))
                {
                        sprintf (str, "%s, %s", szDeviceName, szDeviceVersion);
                        pStringCapDrivers->AddObject (str, (TObject *)xcap);
                }
                else
                {
                        break;
                }
                xcap++;
        } while (true);

        return 0;
}

//---------------------------------------------------------------------------
//  connecting to selected device and starts preview
//---------------------------------------------------------------------------
void TCap::Connect (int Selected)
{
        CAPSTATUS CapStatus;
        int       hsize;

        // capDlgVideoDisplay(hwndVideo);
        // connect to the driver
        if (SelectedDevice != -1)
        {
        capPreview (hwndVideo, FALSE);
        capDriverConnect(hwndVideo, SelectedDevice);
        }

        if (!capDriverConnect(hwndVideo, Selected))
        {
        // ---- Unable to connect to driver
        return;
        }

        // update the driver capabilities
        capDriverGetCaps (hwndVideo, sizeof(CAPDRIVERCAPS), &CapDrvCaps);

        capDlgVideoFormat(ParentHandle);

//-----------------------------------------------------------------------------

//**********Eigene Veränderungen an dem Header*********************************
//-----------------------------------------------------------------------------
        //Die Standarteinstellungen laden
	DWORD dwSize;                                                           // Länge der Formateigenschaften
	BITMAPINFO pbiInfo;                                                     // Bitmap-Eigenschaften der Datei

	dwSize=capGetVideoFormatSize(hwndVideo);                                // Messen der Länge

	capGetVideoFormat(hwndVideo, &pbiInfo, dwSize);                         // Momentane Formatierung laden

	// Einstellen der neuen Werte
	DWORD dwWidth,dwHeight,dwBPP;

        dwWidth=640;                                                            // Horizontale Auflösung
        dwHeight=480;                                                           // Vertikale Auflösung
        dwBPP=24;                                                               // Farbtiefe

	pbiInfo.bmiHeader.biWidth = dwWidth;
	pbiInfo.bmiHeader.biHeight = dwHeight;
	pbiInfo.bmiHeader.biBitCount = (WORD) dwBPP;

	pbiInfo.bmiHeader.biSizeImage = 0;                                      // Größe der reservierten Bytes
	pbiInfo.bmiHeader.biCompression = BI_RGB;                               // Komprimierung (BI_RGB=keine Kompr.)
	pbiInfo.bmiHeader.biClrUsed = 0;                                        // Maximale Anzahl der dargestellten
	pbiInfo.bmiHeader.biClrImportant = 0;                                   // Farben, 0=alle Farben
	pbiInfo.bmiHeader.biPlanes = 1;                                         // Einstellung der Treiberebenen. Muss 1 sein

	pbiInfo.bmiColors->rgbBlue = 0;                                         // Eingabe der Farbverstärkung der
	pbiInfo.bmiColors->rgbGreen = 0;                                        // Grundfarben. 0=keine Verstärkung
	pbiInfo.bmiColors->rgbRed = 0;
	pbiInfo.bmiColors->rgbReserved = 0;                                     // Muss auf 0 gesetzt sein

	//Zurückschreiben zur API
	capSetVideoFormat(hwndVideo, &pbiInfo, dwSize);
//-----------------------------------------------------------------------------

        // Die neu eingestellte Bildgröße wird in den CapStatus geladen
        capGetStatus(hwndVideo, &CapStatus, sizeof(CAPSTATUS));

        hsize = GetSystemMetrics(SM_CYMENU);
        hsize += GetSystemMetrics(SM_CYCAPTION);

        // Das Anzeigefenster wird neu aufgebaut
        SetWindowPos(hwndVideo, NULL, 0, 0, CapStatus.uiImageWidth,
                CapStatus.uiImageHeight, SWP_NOZORDER | SWP_NOMOVE);
        SetWindowPos(ParentHandle, NULL, 0, hsize, CapStatus.uiImageWidth,
                CapStatus.uiImageHeight+hsize, SWP_NOZORDER | SWP_NOMOVE);

        // Stellt die Bildwiederholrate des Vorschaufensters ein
        capPreviewRate (hwndVideo, 33.3);

        // startet die Bildvorschau
        capPreview (hwndVideo, TRUE);

        // Das geöffnete Aufnahmegerät wird gespeichert
        SelectedDevice = Selected;

}

//---------------------------------------------------------------------------
//  Get access to the video source format box
//---------------------------------------------------------------------------
void TCap::Format ()
{
        int hsize;

        CAPSTATUS CapStatus;

        capDlgVideoFormat(hwndVideo);
        // Are there new image dimensions
        capGetStatus(hwndVideo, &CapStatus, sizeof(CAPSTATUS));

        hsize = GetSystemMetrics(SM_CYMENU);
        hsize += GetSystemMetrics(SM_CYCAPTION);

        SetWindowPos(ParentHandle, NULL, 0, hsize, CapStatus.uiImageWidth,
                CapStatus.uiImageHeight+hsize, SWP_NOZORDER | SWP_NOMOVE);
        SetWindowPos(hwndVideo, NULL, 0, 0, CapStatus.uiImageWidth,
                CapStatus.uiImageHeight, SWP_NOZORDER | SWP_NOMOVE);
}
//---------------------------------------------------------------------------
//  Get access to the video source dialog box
//---------------------------------------------------------------------------
void TCap::Source ()
{
        capDlgVideoSource(hwndVideo);
}

//---------------------------------------------------------------------------
//  capture a frame and save it
//---------------------------------------------------------------------------
void TCap::CaptureFrame (char *FileName)
{
        capFileSaveDIB (hwndVideo, FileName);
}
//---------------------------------------------------------------------------

Der Header

//---------------------------------------------------------------------------

#ifndef c_capH
#define c_capH
//---------------------------------------------------------------------------
#include <vfw.h> // video for windows library

class TCap
{
private:

protected:
    HWND ParentHandle;
    HWND hwndVideo;
    CAPDRIVERCAPS CapDrvCaps; // driver capabilities

    int     SelectedDevice;

public:
    TStringList     *pStringCapDrivers;
    int EnumCapDrv();
    void Connect (int Selected);
    void Format ();
    void Source ();
    void CaptureFrame (char *FileName);
  __fastcall TCap(HWND Handle);
  __fastcall ~TCap();
};

#endif

z.B.:
mache referenzbild lade in array.
mache bild lade in array.
bilde die differenz.
rechne die veränderte fläche aus.