Kamera Beispiel

Zeigt, wie man ein Standbild oder ein Video aufnimmt.

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

Ausführen des Beispiels

Zum Ausführen des Beispiels von Qt Creatorauszuführen, öffnen Sie den Modus Welcome und wählen Sie das Beispiel unter Examples aus. Weitere Informationen finden Sie unter Erstellen und Ausführen eines Beispiels.

Das Beispiel implementiert eine Camera Klasse, die als unsere Kamera-Schnittstelle fungiert. Sie verfügt über eine Benutzeroberfläche, Steuerfunktionen, Einstellungswerte und die Möglichkeit, den Speicherort für das Bild oder den Videoclip zu definieren. Sie speichert auch die Bild- und Videoeinstellungen.

Die Klasse Camera verwendet:

Eine Instanz von QCamera, der API-Klassenschnittstelle zur Hardware.
Eine Instanz von QImageCapture zur Aufnahme von Standbildern.
Eine Instanz von QMediaRecorder, um Videos aufzunehmen. Sie enthält auch das Objekt der Benutzeroberfläche.

Der Kamera-Konstruktor

Der Kamerakonstruktor führt einige grundlegende Initialisierungen der Benutzeroberfläche durch, einschließlich der standardmäßigen 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 fragt die Berechtigungen für den Zugriff auf das Eingabegerät ab:

#if QT_CONFIG(permissions) // camera   QCameraPermission cameraPermission; switch (qApp->checkPermission(cameraPermission)) { case Qt::PermissionStatus::Unbestimmt:        qApp->requestPermission(cameraPermission, this, &Camera::init);
       return; case Qt::PermissionStatus::Denied:        qWarning("Camera permission is not granted!");
       return; case Qt::PermissionStatus::Granted: break; } // microphone   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

Eingänge 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);
    connect(ui->exposureCompensation, &QAbstractSlider::valueChanged, this,
            &Camera::setExposureCompensation);

    setCamera(QMediaDevices::defaultVideoInput());

Die meiste Arbeit wird jedoch erledigt, wenn die Funktion setCamera() aufgerufen wird und eine QCameraDevice übergeben wird.

setCamera()

setCamera() stellt verschiedene Verbindungen zwischen der Benutzeroberfläche und den Funktionen der Kameraklasse her, indem sie Signale und Slots verwendet. Sie instanziiert und initialisiert auch die Objekte QCamera, QImageCapture und QMediaRecorder.

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

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

    if (!m_mediaRecorder) {
        m_mediaRecorder.reset(new QMediaRecorder);
        m_captureSession.setRecorder(m_mediaRecorder.data());
        connect(m_mediaRecorder.data(), &QMediaRecorder::recorderStateChanged, this,
                &Camera::updateRecorderState);
        connect(m_mediaRecorder.data(), &QMediaRecorder::durationChanged, this,
                &Camera::updateRecordTime);
        connect(m_mediaRecorder.data(), &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 visuellen Registerkarten für Standbild- 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 des Capturings

Die Kamera ist nun bereit für Benutzerbefehle und wartet 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 einfach 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 entweder takeImage() auf, wenn eine Bildaufnahme gemacht wird, oder ruft record() oder stop() (wenn bereits eine Aufnahme gemacht wurde) auf der QMediaRecorder Instanz auf, wenn ein Video aufgenommen wird.

    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

© 2025 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.