4. Webcam Auflösung

Webcam Auflösung

  • S

    Hallo,

    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. 😞

    0
  • S

    Kann mir keiner helfen? Das wäre echt wichtig, weil ich die Funktion für ein Projekt brauche, das auf 640x480 ausgelegt ist... 😞

    0
  • S

    So learning bei doing.

    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. 😮

    0
  • S

    Scheinbar ist mein Thema ziemlich uninteressant... 😞

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

    0
  • N

    Bei www.codeproject.com gibt es Wrapperklassen für Webcams. Studiere einfach mal Code von anderen Leuten und gucke wie die das machen.
    Ich weiss von Kollegen, dass oft DirectShow für sowas eingesetzt wird.

    0
  • M

    MSDN schrieb:

    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.

    0
  • S

    Ich habs nach langem Rumprobieren jetzt endlich selber geschafft. Trotzdem vielen Dank für die Hilfe!

    0
  • P

    Hi

    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

    0
  • S

    Kann ich gern machen. Jedoch ist er, bis auf die Einstellung der Auflösung der selbe wie auf http://www.cppb.allanpetersen.com/software.htm.

    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
    0
  • K

    an der unit datei hast du nichts geändert? Meine heißt nämlich Unit1.h/.cpp
    wie machst du denn damit nun ein Bild, wenn du nicht die GUI benutzt?
    Ist es möglich das Bild direct als 2d-array zu erhalten(jedes Element ist ein Pixel mit den Farb(bzw Grauwerten))???
    ich wollte nämlich ne console app machen die alle 0.x sekunden ein bild in den arbeitsspeicher schreibt und mit bildpunktarrays(grauwerte) nen bischen rumrechnet.

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

    0
  • M

    [gelöscht wegen Unsinn]

    0
Anmelden zum Antworten