Ich benutze Code::Blocks mit MinGW unter WinXP und versuche gerade zum ersten Mal eine Kamera auszulesen.

Zu dem Zweck habe ich ein Win32 GUI-Projekt erstellt (New->Project->Win32 GUI), so dass ich den Rahmen erstmal habe und mich nur um die Kamera kümmern muss.

Unter 'Build Options->Linker Settings->Link Libraries' habe ich die 'libvfw32.a' eingetragen.

Am Ende dieses vorgefertigten Quelltextes (vollständige Version: siehe unten) habe ich mit

capture_Webcam(hwnd);

meine in kamera.h (hab auch kamera.cpp probiert) enthaltene Funktion:

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

void capture_Webcam(HWND hwnd)
{
    HWND hWndC;

    hWndC = capCreateCaptureWindow(
    (LPSTR) "My Capture Window", // window name if pop-up
    WS_CHILD | WS_VISIBLE,       // window style
    0, 0, 160, 120,              // window position and dimensions
    (HWND) hwnd,
    (int) 11011 /* child ID */);

    SendMessage (hWndC, WM_CAP_DRIVER_CONNECT, 0 /* wIndex */, 0L);

    SendMessage (hWndC, WM_CAP_SEQUENCE, 0, 0L);
}

Vielen Dank,
Sinthoras

P.S.: So, zur Sicherheit nochmal die komplette main.cpp (bis auf die eine Zeile vorgefertigt):

#include <windows.h>
#include "kamera.cpp"
#include <vfw.h>

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
char szClassName[ ] = "CodeBlocksWindowsApp";

int WINAPI WinMain (HINSTANCE hThisInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR lpszArgument,
                     int nCmdShow)
{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default colour as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           "Code::Blocks Template Windows App",       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           544,                 /* The programs width */
           375,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nCmdShow);

    capture_Webcam(hwnd);

    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}

/*  This function is called by the Windows function DispatchMessage()  */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)                  /* handle the messages */
    {
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}

// #include <windows.h>
// #include "kamera.cpp"    // <- Hier wird bereits auf "capCreateCaptureWindow ()" zugegriffen,
// #include <vfw.h>         // <- obwohl "capCreateCaptureWindow ()" hier erst deklariert wird.

#include <windows.h>
#include <vfw.h>
#include "kamera.cpp"

Hoffentlich war das auch Deine Frage.

@merker: Oh, danke, vielen Dank.
(sind ja meist solche kleinen Dummheiten, die man selbst dann nie findet... )

Zu früh gefreut, hab es jetzt so:

#include <windows.h>
#include <vfw.h>
#include "kamera.h"

Und der Fehler kommt immernoch (für alle vfw.h-Funktionen)???

Da steig ich jetzt echt nicht durch...

Doch leider folgt ihm das nächste auf den Fuß:
...\kamera.h:12: undefined reference to `capCreateCaptureWindowA@32'
:: === Build finished: 1 errors, 0 warnings ===

Die entsprechende Datei nochmal:

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

#ifndef _KAMERA_H_
#define _KAMERA_H_

void capture_Webcam(HWND hwnd)
{
    HWND hWndC;

    hWndC = capCreateCaptureWindow(
    (LPSTR) "My Capture Window", // window name if pop-up
    WS_CHILD | WS_VISIBLE,       // window style
    0, 0, 160, 120,              // window position and dimensions
    (HWND) hwnd,
    (int) 11011 /* child ID */);

    //SendMessage (hWndC, WM_CAP_DRIVER_CONNECT, 0 /* wIndex */, 0L);

    //SendMessage (hWndC, WM_CAP_SEQUENCE, 0, 0L);

}
#endif

Mich verwirrt vor allem das ...A@32 hinter der Funktion...
Stört er sich da irgendwie an der Verwendung?
Ist doch eigentlich richtig soweit, oder nicht?

Hab danach gegoogelt, nur dummerweise ist das einzige Ergebnis dazu auf Französisch (so ein Pech...).

Also falls jemand was damit anfangen kann, oder zufällig gut Frantösisch spricht (dann hier )...

Danke euch allen.

Mit 'capCreateCaptureWindow' hat er zwar keine Probleme mehr, aber dafür führen allen unten aufgeführten Zeilen zu '... undeclared' Fehlermeldungen:

capPreview (hwndVideo, FALSE);
    capDriverConnect(hwndVideo, 1);
    capPreviewRate (hwndVideo, 33.3);
    capPreview (hwndVideo, TRUE);

Ich bin mir nicht ganz sicher, aber ich glaube (in der msdn) gelesen zu haben, dass es sich dabei um Makros handelt(?)
Kann es sein, dass er das irgendwie nicht erkennt und deswegen abschmiert?

Danke für eure Hilfe,

Sinthoras

P.S.: Vfw.h ist includelt und aktuell, libvfw32.a wird gelinkt.
P.P.S.: In der msdn steht unter "requirements" nur die Vfw.h, also daran kann es doch eigentlich nicht liegen, oder?

Wo krieg ich denn nur den Compiler her? (ohne IDE)
Den kann ich dann ja mit Code::Blocks nutzen.
Muss ich mich nicht noch in eine neue IDE hineinarbeiten...

Oder kann ich mir auch irgendwo die vollständigen Header und Libraries holen und die mit MinGW nutzen (einfach reinkopieren???) ?

Oder kann ich mir auch irgendwo die vollständigen Header und Libraries holen und die mit MinGW nutzen (einfach reinkopieren???) ?

wenn du mingw kompatible header und libraries findest schon. ich wüsste aber nicht ob es die geben sollte.

Ich bin mir nicht ganz sicher, aber ich glaube (in der msdn) gelesen zu haben, dass es sich dabei um Makros handelt(?)

Das sind in der Tat Makros.
Wenn Du sie (warum auch immer) nicht kompiliert kriegst, dann kannst Du sie auch "per Hand" auseinanderfrickeln :

--------------------
Auszug aus der vfw.h
--------------------
/* SendMessage in C++ */
#define AVICapSM(hwnd,m,w,l)       ( (IsWindow(hwnd)) ? ::SendMessage(hwnd,m,w,l) : 0)
/* SendMessage in C */
#define AVICapSM(hwnd,m,w,l)       ( (IsWindow(hwnd)) ?   SendMessage(hwnd,m,w,l) : 0)

#define capPreview(hwnd, f)        ((BOOL)AVICapSM(hwnd, WM_CAP_SET_PREVIEW, (WPARAM)(BOOL)(f), 0L))
#define capDriverConnect(hwnd, i)  ((BOOL)AVICapSM(hwnd, WM_CAP_DRIVER_CONNECT, (WPARAM)(i), 0L))
#define capPreviewRate(hwnd, wMS)  ((BOOL)AVICapSM(hwnd, WM_CAP_SET_PREVIEWRATE, (WPARAM)(wMS), 0))

---------------------------------------------------
capPreview (hwndVideo, FALSE)  entspricht in etwa :
---------------------------------------------------
if ( IsWindow (hwndVideo) ) {
 return SendMessage  (hwndVideo, WM_CAP_SET_PREVIEW, (WPARAM)(BOOL) FALSE, 0L);
} else {
 return 0;
}
--------
usw. :-)
--------

// vfw.h
#define WM_CAP_START                    WM_USER

#define WM_CAP_DRIVER_CONNECT           (WM_CAP_START+  10)
#define WM_CAP_SET_PREVIEW              (WM_CAP_START+  50)
#define WM_CAP_SET_PREVIEWRATE          (WM_CAP_START+  52)

// winuser.h
#define WM_USER                         0x0400

---------------------------------------
WM_CAP_DRIVER_CONNECT == (WM_USER + 10)
---------------------------------------
usw. :-)

Ich versuch's mal so.

Danke.

Nur steht das alles in meiner vfw.h halt nicht drin, d.h. ich bräuchte irgendwo her eine "heile" vfw.h .

Würde MinGW auch laufen, wenn ich einfach die vom MS-Compiler rüberkopiere?
(Ich frage deshalb vorher, weil ich den ganzen Kram mit IDE und allem erst noch runterladen müsste und das wäre eine Menge verschwendete Zeit, wenn's dann nicht geht.)

Zur Not, falls MinGW mit der vfw.h vom MS-Compiler nicht klarkommt, könnte ich ja immernoch alle Makros per Hand auflösen.
Aber das wäre auf Dauer halt etwas unkompfortabel.

Danke,
Sinthoras

Wenn das geht, ist ja alles in Ordnung.

Danke für Deine Hilfe.