Kamera-Beispiel

Zeigt, wie man ein Standbild aufnimmt oder ein Video aufzeichnet.

Kamera-Anwendungsoberfläche mit Steuerelementen zur Bild- und Videoaufnahme

Das Kamera-Beispiel veranschaulicht, wie Sie Qt Multimedia einige grundlegende Kamerafunktionen implementieren können, um Standbilder aufzunehmen und Videoclips mit Ton aufzunehmen.

Ausführen des Beispiels

Sie können das Beispiel ausführen unter:

Qt Creator
Öffnen Sie den Modus „ Welcome “ und wählen Sie das Beispiel unter „ Examples “ aus. Weitere Informationen finden Sie unter Qt Creator: Tutorial: Erstellen und Ausführen.
Qt Extension for Visual Studio Code
Führen Sie den Befehl „ Qt: Open Qt examples “ aus dem Verzeichnis „ Command Palette “ aus und wählen Sie das Beispiel aus der Liste aus. Weitere Informationen finden Sie unter Qt Extension for Visual Studio Code: Tutorial: Erstellen und Ausführen.

Das Beispiel implementiert eine „ Camera “-Klasse, die als unsere Kameraschnittstelle dient. Sie verfügt über eine Benutzeroberfläche, Steuerungsfunktionen, Einstellwerte und eine Möglichkeit, den Speicherort für das Bild oder den Videoclip festzulegen. Außerdem speichert sie die Bild- und Videoeinstellungen.

Die Klasse „Camera“ verwendet:

Eine Instanz von ` QCamera`, der API-Schnittstelle zur Hardware.
Eine Instanz von ` QImageCapture ` zum Aufnehmen von Standbildern.
Eine Instanz von ` QMediaRecorder ` zum Aufnehmen von Videos. Sie enthält außerdem das Benutzeroberflächenobjekt.

Der Konstruktor von „Camera“

Der Konstruktor von „Camera“ führt einige grundlegende Initialisierungen der Benutzeroberfläche durch, darunter die standardmäßige Deaktivierung aller Schaltflächen.

Camera::Camera() : ui(new Ui::Camera)
{
    ui->setupUi(this);
    // disable all buttons by default
    updateCameraActive(false);
    readyForCapture(false);
    ui->recordButton->setEnabled(false);
    ui->pauseButton->setEnabled(false);
    ui->stopButton->setEnabled(false);
    ui->metaDataButton->setEnabled(false);

Er fordert Berechtigungen für den Zugriff auf Eingabegeräte an:

#if QT_CONFIG(permissions)
    // Kamera
    QCameraPermission cameraPermission;
    switch (qApp->checkPermission(cameraPermission)) {
    case Qt::PermissionStatus::Undetermined:
        qApp->requestPermission(cameraPermission, this, &Camera::init);
       return;
    case Qt::PermissionStatus::Denied:
        qWarning("Camera permission is not granted!");
       return;
    case Qt::PermissionStatus::Granted:
        break;
    }
    // Mikrofon
    QMicrophonePermission microphonePermission;
    switch (qApp->checkPermission(microphonePermission)) {
    case Qt::PermissionStatus::Unbestimmt:
        qApp->requestPermission(microphonePermission, this, &Camera::init);
       return;
    case Qt::PermissionStatus::Denied:
        qWarning("Microphone permission is not granted!");
       return;
    case Qt::PermissionStatus::Granted:
        break;
    }
#endif

Die Eingaben werden zugewiesen:

    m_audioInput.reset(new QAudioInput);
    m_captureSession.setAudioInput(m_audioInput.get());

    // Camera devices:

    videoDevicesGroup = new QActionGroup(this);
    videoDevicesGroup->setExclusive(true);
    updateCameras();

UI-Signale werden mit Slots verbunden, die auf das auslösende Ereignis reagieren:

    connect(&m_devices, &QMediaDevices::videoInputsChanged, this, &Camera::updateCameras);

    connect(videoDevicesGroup, &QActionGroup::triggered, this, &Camera::updateCameraDevice);
    connect(ui->captureWidget, &QTabWidget::currentChanged, this, &Camera::updateCaptureMode);

    connect(ui->metaDataButton, &QPushButton::clicked, this, &Camera::showMetaDataDialog);

    setCamera(QMediaDevices::defaultVideoInput());

Der Großteil der Arbeit wird jedoch beim Aufruf der Funktion `setCamera()` erledigt, wobei ein ` QCameraDevice` übergeben wird.

setCamera()

setCamera() richtet mithilfe von Signalen und Slots verschiedene Verbindungen zwischen der Benutzeroberfläche und den Funktionen der Klasse `Camera` ein. Außerdem werden die Objekte ` QCamera`, ` QImageCapture` und ` QMediaRecorder ` instanziiert und initialisiert.

void Camera::setCamera(const QCameraDevice &cameraDevice)
{
    m_camera.reset(new QCamera(cameraDevice));
    m_captureSession.setCamera(m_camera.get());

    connect(m_camera.get(), &QCamera::activeChanged, this, &Camera::updateCameraActive);
    connect(m_camera.get(), &QCamera::errorOccurred, this, &Camera::displayCameraError);

    if (!m_mediaRecorder) {
        m_mediaRecorder.reset(new QMediaRecorder);
        m_captureSession.setRecorder(m_mediaRecorder.get());
        connect(m_mediaRecorder.get(), &QMediaRecorder::recorderStateChanged, this,
                &Camera::updateRecorderState);
        connect(m_mediaRecorder.get(), &QMediaRecorder::durationChanged, this,
                &Camera::updateRecordTime);
        connect(m_mediaRecorder.get(), &QMediaRecorder::errorChanged, this,
                &Camera::displayRecorderError);
    }

    if (!m_imageCapture) {
        m_imageCapture.reset(new QImageCapture);
        m_captureSession.setImageCapture(m_imageCapture.get());
        connect(m_imageCapture.get(), &QImageCapture::readyForCaptureChanged, this,
                &Camera::readyForCapture);
        connect(m_imageCapture.get(), &QImageCapture::imageCaptured, this,
                &Camera::processCapturedImage);
        connect(m_imageCapture.get(), &QImageCapture::imageSaved, this, &Camera::imageSaved);
        connect(m_imageCapture.get(), &QImageCapture::errorOccurred, this,
                &Camera::displayCaptureError);
    }

Die Registerkarten für Foto- und Videoaufnahmen sind aktiviert:

    m_captureSession.setVideoOutput(ui->viewfinder);

    updateCameraActive(m_camera->isActive());
    updateRecorderState(m_mediaRecorder->recorderState());
    readyForCapture(m_imageCapture->isReadyForCapture());

    updateCaptureMode();

Abschließend wird die Funktion „ start()“ des Objekts „ QCamera “ aufgerufen.

    m_camera->start();

Auslösen der Erfassung

Da die Kamera nun für Benutzerbefehle bereit ist, wartet sie auf ein geeignetes Ereignis. Ein solches Ereignis kann ein Tastendruck auf die Schaltflächen „ Qt::Key_CameraFocus “ oder „ Qt::Key_Camera “ im Anwendungsfenster sein.

„Key_CameraFocus“ zeigt lediglich die Vorschau an und sperrt die Kameraeinstellungen.

}

void Camera::keyPressEvent(QKeyEvent *event)
{
    if (event->isAutoRepeat())
        return;

    switch (event->key()) {
    case Qt::Key_CameraFocus:
        displayViewfinder();
        event->accept();
        break;

Key_Camera ruft bei einer Bildaufnahme entweder `takeImage()` auf oder, bei einer Videoaufnahme, die Methoden ` record() ` oder ` stop() ` (sofern bereits eine Aufnahme läuft) der Instanz ` QMediaRecorder ` auf.

    case Qt::Key_Camera:
        if (m_doImageCapture) {
            takeImage();
        } else {
            if (m_mediaRecorder->recorderState() == QMediaRecorder::RecordingState)
                stop();
            else
                record();
        }
        event->accept();
        break;

Beispielprojekt @ code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.