Back to Qt.io
Contact Us Blog Download Qt
Sur cette page

Exemple d'appareil photo

Montre comment capturer une image fixe ou enregistrer une vidéo.

Interface d'application de la caméra avec commandes d'acquisition d'images et de vidéos

L'exemple de la caméra montre comment vous pouvez utiliser Qt Multimedia pour mettre en œuvre certaines fonctionnalités de base de Camera afin de prendre des photos et d'enregistrer des clips vidéo avec du son.

Exécution de l'exemple

Pour exécuter l'exemple à partir de Qt Creatorouvrez le mode Welcome et sélectionnez l'exemple à partir de Examples. Pour plus d'informations, voir Qt Creator: Tutoriel : Construire et exécuter.

L'exemple met en œuvre une classe Camera qui sert d'interface à notre caméra. Elle possède une interface utilisateur, des fonctions de contrôle, des valeurs de réglage et un moyen de définir l'emplacement où l'image ou le clip vidéo doit être sauvegardé. Elle stocke également les paramètres de l'image et de la vidéo.

La classe Camera utilise :

  • Une instance de QCamera, l'interface de la classe API avec le matériel.
  • Une instance de QImageCapture pour prendre des photos.
  • Une instance de QMediaRecorder pour enregistrer des vidéos. Elle contient également l'objet d'interface utilisateur.

Le constructeur de la caméra

Le constructeur de la caméra effectue une initialisation de base de l'interface utilisateur, notamment en désactivant tous les boutons par défaut.

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);

Il demande des autorisations pour l'accès aux périphériques d'entrée :

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

Les entrées sont assignées :

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

    // Camera devices:

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

Les signaux de l'interface utilisateur sont connectés aux emplacements qui réagissent à l'événement déclencheur :

    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());

Cependant, le plus gros du travail est effectué lorsque la fonction setCamera() est appelée, en passant par un QCameraDevice.

setCamera()

setCamera() établit diverses connexions entre l'interface utilisateur et les fonctionnalités de la classe Camera à l'aide de signaux et d'emplacements. Elle instancie et initialise également les objets QCamera, QImageCapture et QMediaRecorder.

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);
    }

Les onglets visuels d'enregistrement de photos et de vidéos sont activés :

    m_captureSession.setVideoOutput(ui->viewfinder);

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

    updateCaptureMode();

Enfin, la fonction start() de l'objet QCamera est appelée.

    m_camera->start();

Déclenchement de la capture

Maintenant que la caméra est prête à recevoir les commandes de l'utilisateur, elle attend un événement approprié. Cet événement peut être une pression sur les boutons Qt::Key_CameraFocus ou Qt::Key_Camera dans la fenêtre d'application.

Key_CameraFocus affiche simplement l'aperçu et verrouille les paramètres de la caméra.

}

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

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

Key_Camera appellera soit takeImage() s'il s'agit d'une capture d'image, soit record() ou stop() (s'il s'agit déjà d'un enregistrement) sur l'instance QMediaRecorder s'il s'agit d'un enregistrement vidéo.

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

Exemple de projet @ 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.