Sur cette page

QVideoFrame Class

La classe QVideoFrame représente une image de données vidéo. Plus d'informations...

En-tête : #include <QVideoFrame>
CMake : find_package(Qt6 REQUIRED COMPONENTS Multimedia)
target_link_libraries(mytarget PRIVATE Qt6::Multimedia)
qmake : QT += multimedia

Types publics

enum HandleType { NoHandle, RhiTextureHandle }
enum MapMode { NotMapped, ReadOnly, WriteOnly, ReadWrite }

Fonctions publiques

QVideoFrame()
(since 6.8) QVideoFrame(const QImage &image)
QVideoFrame(const QVideoFrameFormat &format)
(since 6.8) QVideoFrame(std::unique_ptr<QAbstractVideoBuffer> videoBuffer)
QVideoFrame(const QVideoFrame &other)
QVideoFrame(QVideoFrame &&other)
~QVideoFrame()
uchar *bits(int plane)
const uchar *bits(int plane) const
int bytesPerLine(int plane) const
qint64 endTime() const
QVideoFrame::HandleType handleType() const
int height() const
bool isMapped() const
bool isReadable() const
bool isValid() const
bool isWritable() const
bool map(QVideoFrame::MapMode mode)
QVideoFrame::MapMode mapMode() const
int mappedBytes(int plane) const
bool mirrored() const
void paint(QPainter *painter, const QRectF &rect, const QVideoFrame::PaintOptions &options)
QVideoFrameFormat::PixelFormat pixelFormat() const
int planeCount() const
QtVideo::Rotation rotation() const
void setEndTime(qint64 time)
void setMirrored(bool mirrored)
void setRotation(QtVideo::Rotation angle)
void setStartTime(qint64 time)
void setStreamFrameRate(qreal rate)
void setSubtitleText(const QString &text)
QSize size() const
qint64 startTime() const
qreal streamFrameRate() const
QString subtitleText() const
QVideoFrameFormat surfaceFormat() const
void swap(QVideoFrame &other)
QImage toImage() const
void unmap()
int width() const
bool operator!=(const QVideoFrame &other) const
QVideoFrame &operator=(QVideoFrame &&other)
QVideoFrame &operator=(const QVideoFrame &other)
bool operator==(const QVideoFrame &other) const

Description détaillée

Un QVideoFrame encapsule les données de pixels d'une image vidéo et des informations sur l'image.

Les trames vidéo peuvent provenir de plusieurs endroits - décodées media, d'une camera, ou générées par programme. La manière dont les pixels sont décrits dans ces trames peut varier considérablement, et certains formats de pixels offrent de meilleures possibilités de compression au détriment de la facilité d'utilisation.

Le contenu en pixels d'une trame vidéo peut être mis en mémoire à l'aide de la fonction map(). Après un appel réussi à map(), il est possible d'accéder aux données vidéo par le biais de diverses fonctions. Certains formats de pixels YUV fournissent les données sur plusieurs plans. La méthode planeCount() renvoie le nombre de plans utilisés.

Lorsqu'elles sont mappées, les données vidéo de chaque plan sont accessibles à l'aide de la fonction bits(), qui renvoie un pointeur vers un tampon. La taille de ce tampon est donnée par la fonction mappedBytes(), et la taille de chaque ligne est donnée par bytesPerLine(). La valeur de retour de la fonction handle() peut également être utilisée pour accéder aux données de la trame à l'aide des API natives du tampon interne (par exemple, un handle de texture OpenGL).

Une image vidéo peut également être associée à des informations d'horodatage. Ces horodatages peuvent être utilisés pour déterminer quand commencer et arrêter l'affichage de la trame.

Les objets QVideoFrame peuvent consommer une quantité importante de mémoire ou de ressources système et ne doivent pas être conservés plus longtemps que ne l'exige l'application.

Remarque : les images vidéo pouvant être coûteuses à copier, QVideoFrame est explicitement partagé, de sorte que toute modification apportée à une image vidéo s'appliquera également à toutes les copies.

Voir également QAbstractVideoBuffer, QVideoFrameFormat, et QVideoFrame::MapMode.

Documentation sur les types de membres

enum QVideoFrame::HandleType

Identifie le type de gestionnaire de mémoire tampon vidéo.

ConstanteValeurDescription
QVideoFrame::NoHandle0La mémoire tampon n'a pas de poignée, ses données ne sont accessibles qu'en mappant la mémoire tampon.
QVideoFrame::RhiTextureHandle1La poignée de la mémoire tampon est définie par l'interface matérielle de rendu (RHI) de Qt. RHI est l'abstraction graphique interne de Qt pour les API 3D, telles que OpenGL, Vulkan, Metal et Direct 3D.

Voir aussi handleType().

enum QVideoFrame::MapMode

Énumère la manière dont les données d'une mémoire tampon vidéo sont mappées dans la mémoire système.

ConstanteValeurDescription
QVideoFrame::NotMapped0x00Le tampon vidéo n'est pas mis en correspondance avec la mémoire.
QVideoFrame::ReadOnly0x01La mémoire mappée est remplie de données provenant du tampon vidéo lorsqu'elle est mappée, mais le contenu de la mémoire mappée peut être supprimé lorsqu'elle n'est pas mappée.
QVideoFrame::WriteOnly0x02La mémoire mappée n'est pas initialisée lorsqu'elle est mappée, mais son contenu, éventuellement modifié, sera utilisé pour remplir le tampon vidéo lorsqu'elle sera démappée.
QVideoFrame::ReadWriteReadOnly | WriteOnlyLa mémoire mappée est alimentée par les données du tampon vidéo, et le tampon vidéo est réalimenté avec le contenu de la mémoire mappée lorsqu'il est désapprouvé.

Voir également mapMode() et map().

Documentation sur les fonctions membres

QVideoFrame::QVideoFrame()

Construit une image vidéo nulle.

[explicit, since 6.8] QVideoFrame::QVideoFrame(const QImage &image)

Construit un QVideoFrame à partir d'un QImage.

Si QImage::Format correspond à l'un des formats de QVideoFrameFormat::PixelFormat, le QVideoFrame contiendra une instance de image et utilisera ce format sans aucune conversion de format de pixel. Dans ce cas, les données de pixels ne seront copiées que si vous appelez QVideoFrame::map avec l'indicateur WriteOnly tout en conservant l'image originale.

Sinon, si QImage::Format ne correspond à aucun format vidéo, l'image est d'abord convertie dans un format (A)RGB pris en charge en utilisant QImage::convertedTo() avec l'indicateur Qt::AutoColor. Cette opération peut entraîner une baisse des performances.

Si QImage::isNull() évalue à true pour l'entrée QImage, le QVideoFrame sera invalide et QVideoFrameFormat::isValid() renverra false.

Cette fonction a été introduite dans Qt 6.8.

Voir également QVideoFrameFormat::pixelFormatFromImageFormat(), QImage::convertedTo() et QImage::isNull().

QVideoFrame::QVideoFrame(const QVideoFrameFormat &format)

Construit une image vidéo du pixel donné format.

[explicit, since 6.8] QVideoFrame::QVideoFrame(std::unique_ptr<QAbstractVideoBuffer> videoBuffer)

Construit un QVideoFrame à partir d'un QAbstractVideoBuffer.

L'adresse videoBuffer spécifiée fait référence à une instance réimplémentée de QAbstractVideoBuffer. L'instance doit contenir un tampon vidéo personnalisé préalloué et doit implémenter QAbstractVideoBuffer::format, QAbstractVideoBuffer::map, et QAbstractVideoBuffer::unmap pour le contenu GPU.

Si videoBuffer est nul ou reçoit un QVideoFrameFormat invalide, les constructeurs créent une image vidéo invalide.

Le cadre créé restera propriétaire du tampon vidéo spécifié pendant toute sa durée de vie. Étant donné que QVideoFrame est implémenté via un objet privé partagé, le tampon vidéo spécifié sera détruit lors de la destruction de la dernière copie du cadre vidéo créé.

Notez que si une image vidéo a été transmise à QMediaRecorder ou à un pipeline de rendu, la durée de vie de l'image n'est pas définie et l'enregistreur de médias peut la détruire dans un autre thread.

QVideoFrame contiendra sa propre instance de QVideoFrameFormat. En invoquant setStreamFrameRate, setMirrored, ou setRotation, le format interne peut être modifié, et surfaceFormat renverra une instance détachée.

Cette fonction a été introduite dans Qt 6.8.

Voir aussi QAbstractVideoBuffer et QVideoFrameFormat.

QVideoFrame::QVideoFrame(const QVideoFrame &other)

Construit une copie peu profonde de other. Comme QVideoFrame est explicitement partagé, ces deux instances refléteront la même image.

[constexpr noexcept] QVideoFrame::QVideoFrame(QVideoFrame &&other)

Construit un QVideoFrame en se déplaçant de other.

[noexcept] QVideoFrame::~QVideoFrame()

Détruit une image vidéo.

uchar *QVideoFrame::bits(int plane)

Renvoie un pointeur sur le début du tampon de données de la trame pour un plane.

Cette valeur n'est valide que lorsque les données de la trame sont mapped.

Les modifications apportées aux données accessibles via ce pointeur (lorsqu'elles sont mappées avec un accès en écriture) ne sont garanties que si unmap() est appelé et si le tampon a été mappé pour l'écriture.

Voir également map(), mappedBytes(), bytesPerLine() et planeCount().

const uchar *QVideoFrame::bits(int plane) const

Renvoie un pointeur sur le début du tampon de données de la trame pour un plane.

Cette valeur n'est valable que lorsque les données de la trame sont mapped.

Si le tampon n'a pas été mappé avec un accès en lecture, le contenu de ce tampon sera initialement non initialisé.

Voir également map(), mappedBytes(), bytesPerLine() et planeCount().

int QVideoFrame::bytesPerLine(int plane) const

Renvoie le nombre d'octets dans une ligne de balayage d'un plane.

Cette valeur n'est valable que lorsque les données de la trame sont mapped.

Voir aussi bits(), map(), mappedBytes() et planeCount().

qint64 QVideoFrame::endTime() const

Renvoie l'heure de présentation (en microsecondes) à laquelle une image doit cesser d'être affichée.

Un temps non valide est représenté par -1.

Voir aussi setEndTime().

QVideoFrame::HandleType QVideoFrame::handleType() const

Renvoie le type de la poignée d'une image vidéo.

Le type de poignée peut être NoHandle, ce qui signifie que la trame est basée sur la mémoire, ou une texture RHI.

int QVideoFrame::height() const

Renvoie la hauteur d'une image vidéo.

bool QVideoFrame::isMapped() const

Identifie si le contenu d'une image vidéo est actuellement mappé dans la mémoire système.

Il s'agit d'une fonction de commodité qui vérifie que MapMode de la trame n'est pas égal à QVideoFrame::NotMapped.

Elle renvoie la valeur true si le contenu de l'image vidéo est stocké dans la mémoire système, et false dans le cas contraire.

Voir également mapMode() et QVideoFrame::MapMode.

bool QVideoFrame::isReadable() const

Identifie si le contenu mappé d'une image vidéo a été lu à partir de l'image lorsqu'elle a été mappée.

Il s'agit d'une fonction de commodité qui vérifie si le site MapMode contient le drapeau QVideoFrame::WriteOnly.

Elle renvoie un message vrai si le contenu de la mémoire mappée a été lu à partir de l'image vidéo, et un message faux dans le cas contraire.

Voir aussi mapMode() et QVideoFrame::MapMode.

bool QVideoFrame::isValid() const

Indique si une image vidéo est valide.

Aucune mémoire tampon vidéo n'est associée à une trame non valide.

Retourne true si la trame est valide, et false si elle ne l'est pas.

bool QVideoFrame::isWritable() const

Indique si le contenu mappé d'une image vidéo sera conservé lorsque l'image sera déplacée.

Il s'agit d'une fonction de commodité qui vérifie si le site MapMode contient l'indicateur QVideoFrame::WriteOnly.

Elle renvoie la valeur true si l'image vidéo est mise à jour lorsqu'elle n'est pas mappée, et false dans le cas contraire.

Remarque : le résultat de la modification des données d'une image mappée en mode lecture seule est indéfini. En fonction de l'implémentation de la mémoire tampon, les modifications peuvent être persistantes ou, pire, altérer une mémoire tampon partagée.

Voir aussi mapMode() et QVideoFrame::MapMode.

bool QVideoFrame::map(QVideoFrame::MapMode mode)

Met en correspondance le contenu d'une trame vidéo avec la mémoire du système (adressable par l'unité centrale).

Dans certains cas, les données de la trame vidéo peuvent être stockées dans la mémoire vidéo ou dans une autre mémoire inaccessible, de sorte qu'il est nécessaire de mapper une trame avant d'accéder aux données des pixels. Cela peut impliquer de copier le contenu, c'est pourquoi il faut éviter de mapper et de démapper à moins que cela ne soit nécessaire.

La carte mode indique si le contenu de la mémoire mappée doit être lu et/ou écrit dans la trame. Si le mode de mappage inclut l'indicateur QVideoFrame::ReadOnly, la mémoire mappée sera remplie avec le contenu de la trame vidéo lors du mappage initial. Si le mode de mappage inclut l'indicateur QVideoFrame::WriteOnly, le contenu de la mémoire mappée éventuellement modifiée sera réécrit dans le cadre lorsqu'il sera démappé.

Lorsqu'il est mappé, le contenu d'une image vidéo est accessible directement via le pointeur renvoyé par la fonction bits().

Lorsque l'accès aux données n'est plus nécessaire, veillez à appeler la fonction unmap() pour libérer la mémoire mappée et éventuellement mettre à jour le contenu de la trame vidéo.

Si la trame vidéo a été mappée en mode lecture seule, il est possible de la mapper plusieurs fois en mode lecture seule (et de la démapper un nombre correspondant de fois). Dans tous les autres cas, il est nécessaire de démapper la trame avant de la mapper une seconde fois.

Remarque : l'écriture dans une mémoire en lecture seule n'est pas définie et peut entraîner des modifications des données partagées ou un plantage.

Retourne true si l'image a été mappée dans la mémoire à l'adresse mode et false dans le cas contraire.

Voir aussi unmap(), mapMode(), et bits().

QVideoFrame::MapMode QVideoFrame::mapMode() const

Renvoie le mode dans lequel une image vidéo a été mappée dans la mémoire système.

Voir aussi map() et QVideoFrame::MapMode.

int QVideoFrame::mappedBytes(int plane) const

Renvoie le nombre d'octets occupés par le plan plane des données de trame mappées.

Cette valeur n'est valide que lorsque les données de la trame sont mapped.

Voir également map().

bool QVideoFrame::mirrored() const

Retourne si l'image doit être reflétée autour de son axe vertical avant d'être affichée.

Les transformations de QVideoFrame, en particulier la rotation et l'effet miroir, ne sont utilisées que pour l'affichage de l'image vidéo et sont appliquées en plus de la transformation de la surface, qui est déterminée par QVideoFrameFormat. La mise en miroir est appliquée après la rotation.

La mise en miroir est généralement nécessaire pour les images vidéo provenant de la caméra frontale d'un appareil mobile.

Voir également setMirrored().

void QVideoFrame::paint(QPainter *painter, const QRectF &rect, const QVideoFrame::PaintOptions &options)

Utilise un site QPainter, painter, pour effectuer le rendu de ce site QVideoFrame vers rect. Les options PaintOptions options peuvent être utilisées pour spécifier une couleur d'arrière-plan et la manière dont rect doit être remplie avec la vidéo.

Remarque : le rendu s'effectue généralement sans accélération matérielle lors de l'utilisation de cette méthode.

QVideoFrameFormat::PixelFormat QVideoFrame::pixelFormat() const

Renvoie le format des pixels de cette image vidéo.

int QVideoFrame::planeCount() const

Renvoie le nombre de plans dans l'image vidéo.

Voir également map().

QtVideo::Rotation QVideoFrame::rotation() const

Renvoie l'angle auquel l'image doit être tournée dans le sens des aiguilles d'une montre avant d'être affichée.

Les transformations de QVideoFrame, en particulier la rotation et la mise en miroir, ne sont utilisées que pour l'affichage de l'image vidéo et sont appliquées en plus de la transformation de la surface, qui est déterminée par QVideoFrameFormat. La rotation est appliquée avant l'effet miroir.

Voir également setRotation().

void QVideoFrame::setEndTime(qint64 time)

Définit la présentation time (en microsecondes) à laquelle une image doit cesser d'être affichée.

Un temps non valide est représenté par -1.

Voir aussi endTime().

void QVideoFrame::setMirrored(bool mirrored)

Indique si le cadre doit être mirrored autour de son axe vertical avant d'être affiché.

Les transformations de QVideoFrame, en particulier la rotation et la mise en miroir, ne sont utilisées que pour l'affichage de l'image vidéo et sont appliquées en plus de la transformation de la surface, qui est déterminée par QVideoFrameFormat. La mise en miroir est appliquée après la rotation.

L'effet miroir est généralement nécessaire pour les images vidéo provenant de la caméra frontale d'un appareil mobile.

La valeur par défaut est false.

Voir également mirrored().

void QVideoFrame::setRotation(QtVideo::Rotation angle)

Définit l'adresse angle à laquelle le cadre doit être tourné dans le sens des aiguilles d'une montre avant d'être affiché.

Les transformations de QVideoFrame, en particulier la rotation et la mise en miroir, ne sont utilisées que pour l'affichage de l'image vidéo et sont appliquées en plus de la transformation de la surface, qui est déterminée par QVideoFrameFormat. La rotation est appliquée avant l'effet miroir.

La valeur par défaut est QtVideo::Rotation::None.

Voir également rotation().

void QVideoFrame::setStartTime(qint64 time)

Définit l'heure de présentation time (en microsecondes) à laquelle le cadre doit être initialement affiché.

Un temps non valide est représenté par -1.

Voir aussi startTime().

void QVideoFrame::setStreamFrameRate(qreal rate)

Définit la trame rate d'un flux vidéo en images par seconde.

Voir également streamFrameRate().

void QVideoFrame::setSubtitleText(const QString &text)

Définit le texte des sous-titres qui doit être rendu avec cette image vidéo à text.

Voir aussi subtitleText().

QSize QVideoFrame::size() const

Renvoie les dimensions d'une image vidéo.

qint64 QVideoFrame::startTime() const

Renvoie l'heure de présentation (en microsecondes) à laquelle la trame doit être affichée.

Un temps non valide est représenté par -1.

Voir aussi setStartTime().

qreal QVideoFrame::streamFrameRate() const

Renvoie la fréquence d'images d'un flux vidéo en images par seconde.

Voir également setStreamFrameRate().

QString QVideoFrame::subtitleText() const

Renvoie le texte du sous-titre qui doit être rendu avec cette image vidéo.

Voir également setSubtitleText().

QVideoFrameFormat QVideoFrame::surfaceFormat() const

Renvoie le format de surface de cette image vidéo.

[noexcept] void QVideoFrame::swap(QVideoFrame &other)

Remplace l'image vidéo actuelle par l'image other.

QImage QVideoFrame::toImage() const

Convertit la trame vidéo actuelle en image.

La conversion est basée sur les données des pixels actuels et sur le site surface format. Les transformations de la trame n'ont pas d'impact sur le résultat puisqu'elles ne sont appliquées que pour la présentation.

void QVideoFrame::unmap()

Libère la mémoire mappée par la fonction map().

Si la fonction MapMode comportait l'indicateur QVideoFrame::WriteOnly, le contenu actuel de la mémoire mappée sera conservé dans la trame vidéo.

unmap() ne doit pas être appelé si la fonction map() a échoué.

Voir également map().

int QVideoFrame::width() const

Renvoie la largeur d'une image vidéo.

bool QVideoFrame::operator!=(const QVideoFrame &other) const

Renvoie true si QVideoFrame et other ne reflètent pas le même cadre.

[noexcept] QVideoFrame &QVideoFrame::operator=(QVideoFrame &&other)

Déplace other dans QVideoFrame.

QVideoFrame &QVideoFrame::operator=(const QVideoFrame &other)

Attribue le contenu de other à ce cadre vidéo. Comme QVideoFrame est explicitement partagé, ces deux instances refléteront le même cadre.

bool QVideoFrame::operator==(const QVideoFrame &other) const

Renvoie true si QVideoFrame et other reflètent le même cadre.

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