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

Exemple d'appareil photo

Explique comment prendre une photo ou enregistrer une vidéo.

Interface de l'application appareil photo avec commandes de capture d'images et de vidéos

L'exemple « Appareil photo » montre comment utiliser Qt Multimedia pour implémenter certaines fonctionnalités de base de l’appareil photo afin de prendre des photos et d’enregistrer des clips vidéo avec son.

Exécution de l'exemple

Vous pouvez exécuter l'exemple à partir de :

Cet exemple implémente une classe « Camera » qui fait office d’interface pour notre caméra. Elle dispose d’une interface utilisateur, de fonctions de contrôle, de paramètres de réglage et d’un moyen de définir l’emplacement où l’image ou le clip vidéo doit être enregistré. Elle enregistrera également les paramètres d’image et de vidéo.

La classe `Camera` utilise :

  • Une instance de ` QCamera`, l’interface API vers 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 Camera

Le constructeur de Camera 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 les autorisations nécessaires pour accéder aux périphériques d'entrée :

#if QT_CONFIG(permissions)
    // caméra
    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::Indéterminé:
        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 attribué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 à des slots 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, l’essentiel du travail est effectué lors de l’appel de la fonction `setCamera()`, à laquelle est transmis un objet ` QCameraDevice`.

setCamera()

setCamera() établit diverses connexions entre l’interface utilisateur et les fonctionnalités de la classe Camera à l’aide de signaux et de slots. 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 « Photo » et « Enregistrement vidéo » 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 qu’un événement approprié se produise. Un tel événement peut être l’actionnement d’une touche parmi les boutons « Qt::Key_CameraFocus » ou « Qt::Key_Camera » de la fenêtre de l’application.

La touche « 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 la méthode `takeImage() ` en cas de capture d’image, soit les méthodes ` record() ` ou ` stop() ` (si l’enregistrement est déjà en cours) sur l’instance ` QMediaRecorder ` lors de l’enregistrement d’une 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 sur 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.