En esta página

Ejemplo de cámara

Muestra cómo capturar una imagen fija o grabar un vídeo.

Interfaz de la aplicación de la cámara con controles para la captura de imágenes y vídeos

El ejemplo de la cámara muestra cómo se puede utilizar Qt Multimedia para implementar algunas funciones básicas de la cámara con las que se pueden tomar fotografías y grabar vídeos con audio.

Ejecución del ejemplo

Puedes ejecutar el ejemplo desde:

El ejemplo implementa una clase ` Camera ` que actúa como nuestra interfaz de cámara. Cuenta con una interfaz de usuario, funciones de control, valores de configuración y un método para definir la ubicación donde se guardará la imagen o el clip de vídeo. Además, almacenará la configuración de imagen y vídeo.

La clase Camera utiliza:

  • Una instancia de ` QCamera`, la interfaz de la clase API para el hardware.
  • Una instancia de ` QImageCapture ` para capturar imágenes fijas.
  • Una instancia de ` QMediaRecorder ` para grabar vídeo. También contiene el objeto de interfaz de usuario.

El constructor de Camera

El constructor de Camera realiza una inicialización básica de la interfaz de usuario, lo que incluye desactivar todos los botones de forma predeterminada.

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

Solicita permisos para acceder al dispositivo de entrada:

#if QT_CONFIG(permissions)
    // cámara
    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

Se asignan los valores de entrada:

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

    // Camera devices:

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

Las señales de la interfaz de usuario están conectadas a las ranuras que reaccionan ante el evento desencadenante:

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

Sin embargo, la mayor parte del trabajo se realiza cuando se llama a la función `setCamera()`, pasándole un ` QCameraDevice`.

setCamera()

setCamera() establece diversas conexiones entre la interfaz de usuario y la funcionalidad de la clase `Camera` mediante señales y ranuras. También instancia e inicializa los objetos ` QCamera`, ` QImageCapture` y ` 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);
    }

Las pestañas visuales de captura de imágenes fijas y grabación de vídeo están activadas:

    m_captureSession.setVideoOutput(ui->viewfinder);

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

    updateCaptureMode();

Por último, se invoca la función ` start()` del objeto ` QCamera `.

    m_camera->start();

Activación de la captura

Ahora que la cámara está lista para recibir comandos del usuario, espera a que se produzca un evento adecuado. Dicho evento puede ser la pulsación de una tecla, ya sea el botón « Qt::Key_CameraFocus » o el botón « Qt::Key_Camera » de la ventana de la aplicación.

Key_CameraFocus se limitará a mostrar la vista previa y a bloquear los ajustes de la cámara.

}

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

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

Key_Camera Llamará a takeImage() si se trata de una captura de imagen, o bien a record() o stop() (si ya se está grabando) en la instancia QMediaRecorder cuando se graba vídeo.

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

Proyecto de ejemplo en 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.