Qt para Linux embebido
Complementos de plataforma para dispositivos Linux embebidos
En los sistemas Linux embebidos, hay varios complementos de plataforma que puedes utilizar: EGLFS, VkKhrDisplay, LinuxFB o Wayland. La disponibilidad de estos complementos depende de cómo esté configurado Qt. De entre ellos, Wayland requiere la presencia de un compositor y proporciona un sistema de ventanas completo que admite múltiples ventanas, de forma similar a X11 o Windows. Los demás funcionan sin ningún sistema de ventanas, lo que significa que la aplicación Qt tiene el control total del renderizado y la salida. Normalmente admiten una «ventana» Qt a pantalla completa por pantalla.
EGLFS es el complemento predeterminado en muchas placas. Si no es adecuado, utiliza la variable de entorno ` QT_QPA_PLATFORM ` para solicitar otro complemento. Como alternativa, para pruebas rápidas, utiliza el argumento de línea de comandos ` -platform ` con la misma sintaxis.
Nota: A partir de Qt 5.0, Qt ya no cuenta con su propia implementación del sistema de ventanas (QWS). Para casos de uso de un solo proceso, Qt Platform Abstraction es una solución superior; los casos de uso multiproceso se admiten a través de Wayland.
Consulte «Configurar un dispositivo Linux embebido» para obtener una visión general de cómo configurar Qt para la compilación cruzada utilizando una cadena de herramientas de Linux embebido.
EGLFS
EGL es una interfaz entre OpenGL y el sistema de ventanas nativo. Qt puede utilizar EGL para la gestión de contextos y superficies; sin embargo, la API no contiene elementos específicos de la plataforma. La creación de una ventana nativa —que no tiene por qué ser necesariamente una ventana real en la pantalla— debe realizarse mediante métodos específicos de la plataforma. Por eso necesitamos el código de adaptación específico para la placa o la GPU. Normalmente, estas adaptaciones se proporcionan como:
- ganchos EGLFS: un único archivo fuente compilado en el complemento de la plataforma
- Integración de dispositivos EGL: complementos cargados dinámicamente
EGLFS es un complemento de plataforma para ejecutar aplicaciones Qt sobre EGL y OpenGL ES 2.0, sin un sistema de ventanas real como X11 o Wayland. Es el complemento recomendado para los dispositivos Linux embebidos modernos que incluyen una GPU.
Además de las aplicaciones de « Qt Quick » y OpenGL nativas, EGLFS también admite ventanas renderizadas por software, como QWidget. En el caso de QWidget, el contenido de los widgets se renderiza mediante la CPU en imágenes, que posteriormente se cargan en texturas y se combinan mediante el complemento.
EGLFS obliga a la primera ventana de nivel superior —ya sea una de QWidget o una de QQuickView— a pasar a pantalla completa. Esta ventana también se elige como la ventana raíz del widget en la que se combinan todos los demás widgets de nivel superior. Por ejemplo, cuadros de diálogo, menús emergentes o cuadros combinados. Este comportamiento es necesario porque, con EGLFS, siempre hay exactamente una ventana nativa y una superficie de ventana EGL; estas pertenecen al widget o a la ventana que se crea primero. Este enfoque funciona bien cuando existe una ventana principal que permanece durante toda la vida útil de la aplicación y el resto de widgets o bien no son de nivel superior, o bien se crean posteriormente, una vez que se muestra la ventana principal.
Existen restricciones adicionales para las ventanas basadas en OpenGL. EGLFS admite una única ventana GL a pantalla completa (a partir de Qt 5.3), como QWindow, QQuickView o QOpenGLWidget, todas ellas basadas en OpenGL. No se admite la apertura de ventanas OpenGL adicionales ni la combinación de dichas ventanas con contenido basado en QWidget; Qt cierra la aplicación con un mensaje de error.
Además, las API diseñadas para plataformas de escritorio o entornos con un sistema de ventanas, como «Arrastrar y soltar», no son compatibles con EGLFS.
Variables de entorno utilizadas por EGLFS
Si es necesario, se puede configurar « eglfs » mediante las siguientes variables de entorno:
| Variable de entorno | Descripción |
|---|---|
QT_QPA_EGLFS_INTEGRATION | Además de los hooks compilados, también es posible utilizar complementos cargados dinámicamente para proporcionar una adaptación específica al dispositivo o al fabricante. Esta variable de entorno impone el uso de un complemento específico. Por ejemplo, si se establece en «eglfs_kms», se utiliza el backend KMS/DRM. Esta opción solo está disponible cuando no se han especificado ganchos estáticos o integrados en la compilación en las especificaciones de fabricación del dispositivo. En la práctica, los ganchos tradicionales integrados en la compilación rara vez se utilizan, ya que casi todos los backends se han migrado a complementos. Las especificaciones de fabricación del dispositivo siguen conteniendo una entrada relevante, aunque opcional, para EGLFS_DEVICE_INTEGRATION: el nombre del backend preferido para ese dispositivo en concreto. Evita configurar esta variable de entorno si hay más de un complemento presente en el sistema de destino. En un entorno de escritorio, se da prioridad a los backends KMS o X11, dependiendo de la presencia de la variable de entorno DISPLAY.Nota: En algunas placas se utiliza un valor especial de |
QT_QPA_EGLFS_PHYSICAL_WIDTH y QT_QPA_EGLFS_PHYSICAL_HEIGHT | Especifica el ancho y la altura de la pantalla física en milímetros. Ten en cuenta que, a partir de Qt 6, el tamaño físico de la pantalla ya no se utiliza para determinar los ppp lógicos. |
QT_QPA_EGLFS_ROTATION | Especifica la rotación aplicada al contenido renderizado por software en aplicaciones basadas en « QWidget ». Los valores admitidos son 180, 90 y -90. Esta variable no se aplica a las ventanas basadas en OpenGL, incluidas las de « Qt Quick ». Las aplicaciones de « Qt Quick » pueden aplicar transformaciones en su escena QML en su lugar. El cursor de ratón estándar eglfs siempre tiene en cuenta este valor, con una imagen del puntero correctamente posicionada y girada, independientemente del tipo de aplicación. Sin embargo, es posible que algunas implementaciones especiales de cursor, como el cursor de hardware del backend KMS/DRM, no admitan la rotación. Esta configuración no tiene ningún efecto en ningún otro aspecto, incluida la entrada táctil. Los backends de entrada táctil evdevtouch y libinput tienen cada uno sus propios mecanismos para configurar la rotación. Consulte «Entradas en un dispositivo Linux integrado » para obtener más información sobre la configuración de la entrada táctil. |
QT_QPA_EGLFS_FORCEVSYNC | Cuando está activada, ` eglfs ` solicita ` FBIO_WAITFORVSYNC ` en el dispositivo framebuffer tras cada llamada a `eglSwapBuffers()`. Esta variable solo es relevante para los backends que dependen del subsistema heredado de Linux ` fbdev `. Normalmente, con un intervalo de intercambio predeterminado de 1, Qt asume que la llamada a eglSwapBuffers() se encarga de la sincronización vertical (vsync); si no es así (por ejemplo, debido a errores del controlador), prueba a establecer QT_QPA_EGLFS_FORCEVSYNC en un valor distinto de cero. |
QT_QPA_EGLFS_FORCE888 | Cuando se establece, se ignoran los tamaños de los canales de color rojo, verde y azul cuando ` eglfs ` crea un nuevo contexto, ventana o superficie fuera de pantalla. En su lugar, el complemento solicita una configuración de 8 bits por canal. Esto puede resultar útil en dispositivos en los que, por defecto, se eligen configuraciones con menos de 32 o 24 bits por píxel (por ejemplo, 5-6-5 o 4-4-4), a pesar de saber que no son ideales, por ejemplo, debido a los efectos de bandas. En lugar de modificar el código de la aplicación, esta variable ofrece un atajo para forzar configuraciones de 24 o 32 bpp. |
Además, están disponibles las siguientes variables, de uso menos habitual:
| Variable de entorno | Descripción |
|---|---|
QT_QPA_EGLFS_FB | Anula el dispositivo del búfer de fotogramas. El valor por defecto es /dev/fb0. En la mayoría de las plataformas integradas, esta variable no es muy relevante, ya que el búfer de fotogramas solo se utiliza para consultar ajustes como las dimensiones de la pantalla. Sin embargo, en determinados dispositivos, esta variable permite especificar qué pantalla utilizar en configuraciones con varias pantallas, de forma similar al parámetro fb de LinuxFB. |
QT_QPA_EGLFS_WIDTH y QT_QPA_EGLFS_HEIGHT | Contiene el ancho y la altura de la pantalla en píxeles. Aunque eglfs intenta determinar las dimensiones a partir del dispositivo de framebuffer /dev/fb0, esto no siempre funciona. Puede ser necesario especificar los tamaños manualmente. |
QT_QPA_EGLFS_DEPTH | Anula la profundidad de color de la pantalla. En plataformas en las que el dispositivo de framebuffer /dev/fb0 no está disponible o la consulta no se realiza correctamente, se utiliza el valor por defecto 32. Utiliza esta variable para anular dichos valores por defecto.Nota: Esta variable solo afecta al valor de profundidad de color que devuelve QScreen. No tiene relación alguna con las configuraciones de EGL ni con la profundidad de color utilizada para el renderizado de OpenGL. |
QT_QPA_EGLFS_SWAPINTERVAL | Por defecto, se solicita un intervalo de intercambio de 1. Esta variable permite sincronizarse con la frecuencia de refresco vertical de la pantalla. Utiliza esta variable para anular el valor del intervalo de intercambio. Por ejemplo, si se pasa el valor 0, se desactiva el bloqueo en el intercambio, lo que da como resultado una ejecución tan rápida como sea posible sin ninguna sincronización. |
QT_QPA_EGLFS_DEBUG | Cuando está activada, se muestra cierta información de depuración en la salida de depuración. Por ejemplo, se muestran el valor de entrada QSurfaceFormat y las propiedades de la configuración EGL elegida al crear un nuevo contexto. Si se utiliza junto con la variable QSG_INFO de Qt Quick, se puede obtener información útil para resolver problemas relacionados con la configuración EGL. |
Registro
Además de QT_QPA_EGLFS_DEBUG, eglfs también es compatible con el moderno sistema de registro categorizado de Qt. Están disponibles las siguientes categorías de registro:
qt.qpa.egldeviceintegration– Habilita el registro para los backends cargados dinámicamente. Utiliza esta categoría para comprobar qué backend se está utilizando.qt.qpa.input– Activa la salida de depuración tanto desde los controladores de entrada deevdevcomo delibinput. Utiliza esta categoría para comprobar si se ha reconocido y abierto un dispositivo de entrada concreto.qt.qpa.eglfs.kms– Activa el registro detallado en el backend KMS/DRM.
Después de ejecutar configure, asegúrate de revisar su salida. Esta es la forma más fácil y rápida de identificar si tienes habilitado el backend EGLFS necesario, libudev o libinput. En resumen, si aparece un «no» no deseado en la salida de configure, ejecuta:
./configure -vpara activar la salida detallada, de modo que puedas ver las invocaciones del compilador y del enlazador para cada prueba de configure.
Nota: Si te encuentras con errores relacionados con encabezados o bibliotecas que faltan, o con fallos del enlazador aparentemente crípticos, a menudo son un indicio de que el sysroot está incompleto o dañado y no tiene relación con Qt.
A modo de ejemplo, al compilar para la Raspberry Pi con los controladores gráficos propietarios de Broadcom, la salida debería contener algo similar a lo siguiente:
QPA backends:
EGLFS ................................ yes
EGLFS details:
EGLFS i.Mx6 ........................ no
EGLFS i.Mx6 Wayland ................ no
EGLFS EGLDevice .................... no
EGLFS GBM .......................... no
EGLFS Mali ......................... no
EGLFS Raspberry Pi ................. yes
EGL on X11 ......................... noSi no es así, no es recomendable continuar con la compilación, ya que los gráficos acelerados no funcionarán sin el backend específico de Raspberry Pi, aunque el resto de Qt se compile correctamente.
VkKhrDisplay
Mientras que EGLFS solo es compatible con OpenGL (ES), VkKhrDisplay es un complemento de plataforma experimental que admite el renderizado con la API Vulkan. Para enumerar las pantallas y configurar el renderizado, se basa en la familia de extensiones VK_KHR_display. Ten en cuenta que no es seguro que una implementación de Vulkan dentro de una pila gráfica admita esta funcionalidad. Actualmente, este complemento de plataforma se ha verificado y probado con Mesa y V3DV ejecutándose en una Raspberry Pi 4.
Este complemento de plataforma no es compatible con OpenGL ni con ningún tipo de renderizado por software. Por lo tanto, cualquier intento de mostrar una interfaz de usuario basada en « QWidget » fallará. El único tipo de superficie QWindow compatible es « QSurface::VulkanSurface ». Para las aplicaciones Qt Quick, esto implica que el renderizado basado en Vulkan debe forzarse, ya sea estableciendo « QSG_RHI_BACKEND=vulkan » en el entorno o llamando a « QQuickWindow::setGraphicsApi » (QSGRendererInterface::Vulkan); esto debe hacerse con antelación, antes de crear un « QQuickWindow » o un « QQuickView ».
Para utilizar este complemento de la plataforma, ejecuta la aplicación con -platform vkkhrdisplay o establece QT_QPA_PLATFORM en vkkhrdisplay. El complemento solo se compila cuando Qt está configurado con soporte para Vulkan.
Actualmente no se han implementado la configuración avanzada al estilo EGLFS (por ejemplo, el archivo de configuración JSON) ni la salida a varias pantallas desde la misma aplicación. No obstante, las aplicaciones pueden elegir la pantalla que desean utilizar mediante variables de entorno.
Para determinar los valores de índice, consulta los registros que el complemento muestra en la salida de depuración. Actualmente, estos registros no están categorizados (se muestran mediante ` qDebug`), ya que en la mayoría de los casos es imprescindible revisarlos para garantizar que el complemento seleccione la pantalla y el modo adecuados.
QT_VK_DISPLAY_INDEX- Cuando se establece, se utiliza la pantalla con el índice indicado.QT_VK_MODE_INDEX- Cuando está activado, se utiliza el modo con el índice especificado.QT_VK_PHYSICAL_DEVICE_INDEX- Cuando se activa, se utiliza el dispositivo físico Vulkan con el índice indicado. Esto no será relevante en la mayoría de los casos en entornos embebidos. Ten en cuenta que el resto de la pila gráfica de Qt también utiliza esta variable.
El manejo de la entrada (teclado, ratón, pantalla táctil) es similar al de EGLFS, y admite evdev, libinput y tslib. Sin embargo, no se ha implementado la representación del cursor del ratón. Esto se debe a que en este entorno no existe el concepto de cursor de hardware, y renderizar un cursor con Vulkan dentro del complemento de plataforma, de forma similar a lo que hace EGLFS con OpenGL, resulta problemático por múltiples razones. Por lo tanto, este complemento de plataforma no es adecuado para la entrada basada en el ratón por el momento.
Las variables de entorno relacionadas son:
QT_QPA_DISABLE_INPUT- Desactiva la entrada por teclado, ratón y tacto.QT_QPA_NO_LIBINPUT- Da prioridad a los controladores de entrada basados en evdev, incluso cuando libinput está disponible.QT_QPA_TSLIB- Solicita el uso de la biblioteca heredada tslib.
LinuxFB
Este complemento escribe directamente en el framebuffer a través del subsistema fbdev de Linux. Solo se admite contenido renderizado por software. Ten en cuenta que, en algunas configuraciones, es previsible que el rendimiento de la pantalla sea limitado. Para utilizar aplicaciones de tipo « Qt Quick » con este complemento de plataforma, debe utilizarse el backend de grafo de escena « software », ya sea estableciendo « QT_QUICK_BACKEND=software » en el entorno, o llamando a « setGraphicsApi()» con « QSGRendererInterface::Software ». Se admiten aplicaciones de tipo « QWidget », o « QWindow » con un tipo de superficie « QSurface::RasterSurface », pero esto no incluye widgets especiales como « QOpenGLWidget ».
Dado que fbdev está quedando obsoleto en el núcleo de Linux, también está disponible la compatibilidad con los «dumb buffers» de DRM. Para utilizarlo, establezca la variable de entorno QT_QPA_FB_DRM en un valor distinto de cero. Cuando se configura así, siempre que su sistema admita los «dumb buffers», no se accederá a dispositivos de framebuffer heredados como /dev/fb0. En su lugar, el renderizado se configura a través de las API de DRM, de forma similar al backend eglfs_kms en EGLFS. La salida cuenta con doble búfer y cambio de página, lo que proporciona una sincronización vertical (vsync) adecuada también para el contenido renderizado por software.
Nota: Cuando se utilizan «dumb buffers», ninguna de las opciones descritas a continuación es aplicable, ya que propiedades como los tamaños físico y lógico de la pantalla se consultan automáticamente.
Especificación de ajustes adicionales
El complemento « linuxfb » permite especificar ajustes adicionales mediante la variable de entorno « QT_QPA_PLATFORM » o la opción de línea de comandos « -platform ». Por ejemplo, « QT_QPA_PLATFORM=linuxfb:fb=/dev/fb1 » especifica que se debe utilizar el dispositivo de framebuffer « /dev/fb1 » en lugar del predeterminado « fb0 ». Para especificar varios ajustes, sepárelos con dos puntos (:).
| Configuración | Descripción |
|---|---|
fb=/dev/fbN | Especifica los dispositivos de framebuffer. En configuraciones con varias pantallas, este parámetro permite ejecutar la aplicación en diferentes pantallas. Actualmente, no hay forma de utilizar varios framebuffers desde una sola aplicación Qt. |
size=<width>x<height> | Especifica el tamaño de la pantalla en píxeles. El complemento intenta consultar las dimensiones de la pantalla, tanto físicas como lógicas, a partir del dispositivo de búfer de fotogramas. Sin embargo, es posible que esta consulta no siempre ofrezca resultados correctos; puede que sea necesario especificar los valores de forma explícita. |
mmsize=<width>x<height> | Especifica la anchura y la altura físicas en milímetros. |
offset=<width>x<height> | Especifica el desplazamiento en píxeles de la esquina superior izquierda de la pantalla. La posición predeterminada es (0, 0). |
nographicsmodeswitch | Especifica que no se cambie el terminal virtual al modo gráfico (KD_GRAPHICS). Normalmente, al activar el modo gráfico se desactivan el cursor parpadeante y el apagado de la pantalla. Sin embargo, cuando se establece este parámetro, también se omiten esas dos funciones. |
tty=/dev/ttyN | Anula la consola virtual. Solo se utiliza cuando no está activada la opción « nographicsmodeswitch ». |
A partir de Qt 5.9, se ha sincronizado el comportamiento de EGLFS y LinuxFB en lo que respecta a la política de dimensionamiento de ventanas: la primera ventana de nivel superior se fuerza a cubrir toda la pantalla con ambos complementos de plataforma. Si no se desea este comportamiento, establezca la variable de entorno QT_QPA_FB_FORCE_FULLSCREEN en 0 para restablecer el comportamiento de las versiones anteriores de Qt.
Salida de pantalla
El nivel de compatibilidad para dirigir una o más pantallas desde una única aplicación Qt varía entre los complementos de plataforma. La compatibilidad suele depender del dispositivo y de su pila gráfica.
EGLFS con el backend eglfs_kms
Cuando se utiliza el backend KMS/DRM, EGLFS informa de todas las pantallas disponibles mediante ` QGuiApplication::screens()`. Las aplicaciones pueden dirigir diferentes ventanas a diferentes pantallas mediante ` QWindow::setScreen()`.
Nota: Sigue aplicándosela restricción de una única ventana a pantalla completa por pantalla. Tampoco se admite el cambio de pantalla después de hacer visible ` QWindow `. Por lo tanto, es esencial que las aplicaciones integradas realicen todas las llamadas necesarias a ` QWindow::setScreen()` antes de llamar a ` QWindow::show()`.
Cuando se empieza a desarrollar en un dispositivo integrado concreto, a menudo es necesario comprobar el comportamiento del dispositivo y de los controladores, así como que las pantallas conectadas funcionan correctamente. Una forma sencilla de hacerlo es utilizar el ejemplo «hellowindow ». Al ejecutarlo con los argumentos « -platform eglfs --multiscreen --timeout », se muestra un logotipo de Qt giratorio en cada pantalla conectada durante unos segundos.
Configuración personalizada
El backend KMS/DRM también admite configuraciones personalizadas a través de un archivo JSON. Para habilitar esta opción, establece la variable de entorno ` QT_QPA_EGLFS_KMS_CONFIG ` con el nombre del archivo. También puedes integrar este archivo en la aplicación mediante el sistema de recursos de Qt.
La mayoría de estas opciones de configuración se aplican a todos los backends basados en KMS/DRM, independientemente de la tecnología de gestión de búferes (GBM o EGLStreams).
Nota: Los archivosde configuración se consideran contenido de confianza que está totalmente controlado y gestionado por el creador del dispositivo o la plataforma. No está previsto que se muestren al usuario final de ninguna forma.
A continuación se muestra un ejemplo de configuración:
{
"device": "/dev/dri/card1",
"hwcursor": false,
"pbuffers": true,
"outputs": [
{
"name": "VGA1",
"mode": "off"
},
{
"name": "HDMI1",
"mode": "1024x768"
}
]
}Aquí configuramos el dispositivo especificado para que:
- No utilice el cursor de hardware (recurre a la representación del cursor del ratón mediante OpenGL; por defecto, los cursores de hardware están habilitados, ya que son más eficientes).
- Admita « QOffscreenSurface » con superficies pbuffer EGL estándar (por defecto, esta opción está desactivada y se utiliza en su lugar una superficie gbm).
- La salida por el conector VGA está desactivada, mientras que la salida HDMI está activa con una resolución de 1024x768.
Además, esta configuración también desactiva la búsqueda de dispositivos a través de libudev; en su lugar, se utiliza el dispositivo especificado.
Cuando no se define « mode », se elige el modo preferido del sistema. Los valores aceptados para « mode » son: « off », « current », « preferred », « skip », «widthxheight», «widthxheight», «@vrefresh» o una cadena de modelo de línea.
Al especificar « current », se elige un modo con una resolución que coincide con la actual. Dado que la configuración del modo solo se realiza cuando el modo deseado es realmente diferente del activo (a menos que se fuerce mediante la variable de entorno « QT_QPA_EGLFS_ALWAYS_SET_MODE »), este valor resulta útil para conservar el modo actual y cualquier contenido de los planos que Qt no haya modificado.
skip hace que se ignore el conector de salida como si estuviera desconectado. « off » es similar, pero cambia el modo y apaga la pantalla.
Comportamiento por defecto
Por defecto, todas las pantallas notificadas por la capa DRM se tratan como un único escritorio virtual grande. La implementación del cursor del ratón tiene esto en cuenta y se desplaza por las pantallas como es de esperar. Aunque no es recomendable, puedes desactivar el escritorio virtual configurando separateScreens como false en la configuración.
Por defecto, el escritorio virtual se forma de izquierda a derecha, según el orden de los conectores tal y como lo indica el sistema. Para cambiar esto, establece virtualIndex en un valor que comience por 0.
Por ejemplo, la siguiente configuración utiliza la resolución preferida, pero garantiza que el lado izquierdo del escritorio virtual sea la pantalla conectada al puerto HDMI, mientras que el lado derecho sea la pantalla conectada al DisplayPort:
{
"device": "drm-nvdc",
"outputs": [
{
"name": "HDMI1",
"virtualIndex": 0
},
{
"name": "DP1",
"virtualIndex": 1
}
]
}El orden de los elementos en la matriz no es relevante. Las salidas con índices virtuales no especificados se colocan después de las demás, conservando el orden original de la lista de conectores DRM.
Para crear un espacio de escritorio vertical (es decir, para apilar de arriba abajo en lugar de de izquierda a derecha), añade una propiedad « virtualDesktopLayout » después de « device » con el valor « vertical ».
Advertencia: Se recomienda que todas las pantallas del escritorio virtual utilicen la misma resolución; de lo contrario, elementos como el cursor del ratón pueden comportarse de forma inesperada al entrar en áreas que solo existen en una pantalla concreta.
Cuando virtualIndex no es suficiente, se puede utilizar la propiedad virtualPos para especificar explícitamente la posición superior izquierda de la pantalla en cuestión. Tomando el ejemplo anterior y suponiendo una resolución de 1080p para HDMI1, el siguiente fragmento de código coloca una segunda pantalla HDMI debajo de la primera:
{
...
"outputs": [
...
{
"name": "HDMI2",
"virtualPos": "0, 1080"
}
]
}Nota: Evita este tipo de configuraciones cuando se requiera el uso del ratón. El comportamiento del cursor del ratón puede ser imprevisto con diseños no lineales. El uso táctil no debería presentar problemas.
Consulta automática del tamaño físico de la pantalla
En algunos casos, la detección automática del tamaño físico de la pantalla a través de DRM puede fallar. Normalmente, se utilizarían las variables de entorno ` QT_QPA_EGLFS_PHYSICAL_WIDTH ` y ` QT_QPA_EGLFS_PHYSICAL_HEIGHT ` para proporcionar los valores que faltan. Esto ya no es adecuado cuando hay varias pantallas. En su lugar, utiliza las propiedades ` physicalWidth ` y ` physicalHeight ` de la lista ` outputs ` para especificar los tamaños en milímetros.
Nota: Se desaconseja utilizar tamaños físicosdiferentes y, por lo tanto, DPI lógicos distintos, ya que esto puede provocar problemas inesperados debido a que algunos componentes de la pila gráfica no reconocen la presencia de varias pantallas y se basan únicamente en los valores de la primera pantalla.
Salidas activas e instancias de QScreen
Cada salida activa del array ` outputs ` se corresponde con una instancia ` QScreen ` notificada por ` QGuiApplication::screens()`. Por defecto, la pantalla principal que notifica ` QGuiApplication::primaryScreen()` es la que se ha registrado en primer lugar. Si no se utiliza ` virtualIndex`, esto significa que la decisión se basa en el orden de los conectores DRM. Para anular esto, establezca la propiedad ` primary ` en ` true ` en la entrada deseada de la lista ` outputs `.
Por ejemplo, para garantizar que la pantalla correspondiente a la salida VGA sea la principal, incluso cuando el sistema indique primero la salida HDMI, haz lo siguiente:
{
"device": "/dev/dri/card0",
"outputs": [
{ "name": "HDMI1" },
{ "name": "VGA1", "mode": "1280x720", "primary": true },
{ "name": "LVDS1", "mode": "off" }
]
}Para la resolución de problemas, puede resultar útil habilitar los registros de depuración del backend de KMS/DRM. Para ello, habilita la regla de registro categorizada « qt.qpa.eglfs.kms ».
Nota: En un entorno integrado, los escritorios virtuales tienen más limitaciones en comparación con un sistema de ventanas completo. Se debe evitar que las ventanas se superpongan en varias pantallas, que no estén a pantalla completa o que se desplacen de una pantalla a otra, ya que es posible que no funcionen como se espera.
Un caso de uso habitual
El caso de uso más habitual y mejor compatible para una configuración multipantalla es abrir una ventana dedicada « QQuickWindow » o « QQuickView » para cada pantalla. Con el bucle de renderizado predeterminado « threaded » del grafo de escena « Qt Quick », cada una de estas ventanas dispondrá de su propio hilo de renderizado dedicado. Esto es positivo porque los hilos se pueden regular de forma independiente en función de la sincronización vertical (vsync) y no interferirán entre sí. Con el bucle basic, esto puede resultar problemático y provocar que las animaciones se vean afectadas.
Por ejemplo, detectar todas las pantallas conectadas y crear un ` QQuickView ` para cada una de ellas se puede hacer así:
int main(int argc, char **argv)
{
QGuiApplication app(argc, argv);
QVector<QQuickView *> views;
for (QScreen *screen : app.screens()) {
QQuickView *view = new QQuickView;
view->setScreen(screen);
view->setResizeMode(QQuickView::SizeRootObjectToView);
view->setSource(QUrl("qrc:/main.qml"));
QObject::connect(view->engine(), &QQmlEngine::quit, qGuiApp, &QCoreApplication::quit);
views.append(view);
view->showFullScreen();
}
int result = app.exec();
qDeleteAll(views);
return result;
}Funciones avanzadas de eglfs_kms
Clonación (duplicación)
Se admite la clonación (duplicación) de pantalla. Esto se habilita mediante la propiedad « clones »:
{
"device": "/dev/dri/card0",
"outputs": [
{ "name": "HDMI1", "mode": "1920x1080" },
{ "name": "DP1", "mode": "1920x1080", "clones": "HDMI1" }
]
}En este caso, el contenido de la pantalla conectada a través de DisplayPort será el mismo que el de la pantalla HDMI. Esto se garantiza enviando el mismo búfer a ambas.
Sin embargo, esta función solo funciona si las resoluciones son iguales, no hay incompatibilidades en cuanto a los formatos de búfer aceptados y la aplicación no tiene ninguna salida en el QScreen asociado a un destino de clonación. En la práctica, esto último significa que ningún « QWindow » asociado al « QScreen » en cuestión —DP1 en el ejemplo— debe realizar jamás una operación « QOpenGLContext::swapBuffers()». Depende de la configuración y de la aplicación garantizar que así sea.
Modo sin pantalla mediante nodos de renderizado DRM
Se admite el modo sin pantalla a través de nodos de renderizado DRM. Esto permite realizar cálculos en la GPU (shaders de cálculo OpenGL, OpenCL) o renderizado OpenGL fuera de pantalla sin necesidad de privilegios de maestro DRM. En este modo, las aplicaciones pueden funcionar incluso cuando ya hay otro proceso generando salida en la pantalla.
Limitarse a cambiar ` device ` de ` /dev/dri/card0 ` a ` /dev/dri/renderD128 ` no sirve de nada por sí solo, ya que hay una serie de operaciones que no se pueden realizar en modo sin pantalla. Por lo tanto, esto debe combinarse con la propiedad ` headless `, por ejemplo:
{
"device": "/dev/dri/renderD128",
"headless": "1024x768"
}Hay que tener en cuenta que el tamaño de las ventanas sigue ajustándose al tamaño de la pantalla —ahora virtual—, de ahí la necesidad de especificar un tamaño en la propiedad headless. Tampoco existe la limitación basada en vsync.
Una vez habilitado, las aplicaciones tienen dos opciones habituales para realizar el renderizado fuera de pantalla en modo sin interfaz gráfica:
Utilizar una ventana normal, como una subclase de ` QOpenGLWindow `, dirigida al framebuffer predeterminado de la ventana, lo que en la práctica significa un ` gbm_surface `:
MyOpenGLWindow w;
w.show(); // will not actually show up on screen
w.grabFramebuffer().save("output.png");O el enfoque típico fuera de pantalla con un FBO adicional:
QOffscreenSurface s;
s.setFormat(ctx.format());
s.create();
ctx.makeCurrent(&s);
QOpenGLFramebufferObject fbo(1024, 768);
fbo.bind();
ctx.functions()->glClearColor(1, 0, 0, 1);
ctx.functions()->glClear(GL_COLOR_BUFFER_BIT);
fbo.toImage().save("output.png");
ctx.doneCurrent();Selección de la API DRM
KMS/DRM se puede utilizar con dos API de DRM diferentes: la heredada y la atómica. La principal ventaja de la API atómica de DRM es que permite varias actualizaciones del plano DRM dentro del mismo bucle de renderizado, mientras que la API heredada requeriría una actualización del plano por cada vsync.
La API «atomic» resulta útil cuando tu aplicación necesita superponer contenido en capas, manteniendo todas las actualizaciones dentro de la misma sincronización vertical (vsync). Sin embargo, no todos los dispositivos son compatibles con esta API y es posible que no esté disponible en algunos dispositivos más antiguos. El backend de KMS utilizará por defecto la API «legacy», pero puedes habilitar la API «atomic» de DRM estableciendo la variable de entorno ` QT_QPA_EGLFS_KMS_ATOMIC ` en 1.
También puede resultar útil utilizar un framebuffer más pequeño que la resolución de la pantalla. Esto es posible con la API atómica de DRM utilizando el parámetro ` size ` en el archivo JSON. El ejemplo siguiente utiliza un framebuffer de 1280x720 en un modo de vídeo de 3840x2160:
{
"device": "/dev/dri/card0",
"outputs": [
{ "name": "HDMI1", "mode": "3840x2160", "size": "1280x720", "format": "argb8888" }
]
}Conexión y recarga en caliente de EGLFS
Si se configura un archivo de configuración KMS mediante ` QT_QPA_EGLFS_KMS_CONFIG`, el archivo al que se hace referencia será supervisado por un ` QFileSystemWatcher`. Cualquier cambio en este archivo provocará que se vuelva a leer y se realicen las actualizaciones pertinentes. Por ejemplo: cambios de disposición, cambios de modo o encendido/apagado de pantallas.
De manera similar, aunque de forma estrictamente opcional, se puede configurar QT_QPA_EGLFS_HOTPLUG_ENABLED, lo que permitirá que QDeviceDiscovery supervise el dispositivo KMS en busca de cambios, como pantallas conectadas o desconectadas.
Ambas funciones pueden utilizarse, y de hecho suelen utilizarse, en paralelo.
Para facilitar adecuadamente los cambios dinámicos que se desencadenan con la conexión en caliente y la recarga en caliente, es importante reaccionar creando y destruyendo ventanas en las pantallas que aparecen y desaparecen, respectivamente.
Código de ejemplo:
#include <QGuiApplication>
#include <QQuickView>
#include <QQuickItem>
#include <QScreen>
#include <QQmlContext>
QHash<QString, QQuickView*> screenNameToViewMap;
int main(int argc, char* argv[])
{
QGuiApplication app(argc,argv);
app.setQuitOnLastWindowClosed(false);
auto lRemove = [&](QScreen *screen) {
if (screen->name().compare(QStringLiteral("qt_Headless")) == 0)
return;
if (!screenNameToViewMap.contains(screen->name()))
return;
QQuickView *view = screenNameToViewMap.take(screen->name());
delete view;
};
auto lAdd = [&](QScreen *screen) {
if (screen->handle() == nullptr)
return;
if (screen->name().compare(QStringLiteral("qt_Headless")) == 0)
return;
if (screenNameToViewMap.contains(screen->name()))
return;
QQuickView *view = new QQuickView;
view->setSource(QUrl(QStringLiteral("qrc:/main.qml")));
view->setScreen(screen); // This is not as important as the next line, but good practice
view->setGeometry(screen->geometry()); // This is vital! Otherwise QWindow::show (/QWindowPrivate::create) will change the screen!
view->show();
screenNameToViewMap.insert(screen->name(), view);
};
QObject::connect(&app, &QGuiApplication::screenAdded, &app, lAdd, Qt::QueuedConnection);
QObject::connect(&app, &QGuiApplication::screenRemoved, &app, lRemove);
for (QScreen *screen : app.screens())
lAdd(screen);
return app.exec();
}Fíjate en la línea del ejemplo anterior relativa a « QWindow::setGeometry »: ¡es fundamental para que las ventanas aparezcan en la pantalla a la que están destinadas!
Dado que las mismas señales existen también para QML, se puede escribir código equivalente en QML.
Especialmente en el caso de « QT_QPA_EGLFS_HOTPLUG_ENABLED », es fundamental adaptar el código, ya que algunas pantallas se comportarán como si estuvieran desconectadas cuando se apaguen. Si no se habilita esta función, ni Qt ni el código a nivel de aplicación recibirán notificación alguna sobre las desconexiones. Por lo general, todos los recursos del backend permanecerán intactos y, por lo tanto, la pantalla volverá a aparecer como si nada hubiera pasado. Con QT_QPA_EGLFS_HOTPLUG_ENABLED, los recursos de Qt en la pantalla (p. ej., QScreen, QPlatformScreen, backing-store, etc.) se destruirán y se volverán a crear al conectarse (p. ej., al volver a encender la pantalla). Por lo tanto, los recursos a nivel de aplicación (p. ej., QWindow) también deben volver a crearse.
La pantalla de reserva denominada «qt_Headless» está ahí para facilitar cualquier cambio hacia y desde configuraciones sin pantalla. En el caso de las ventanas a nivel de aplicación, esta pantalla puede y debe ignorarse en la mayoría de los casos.
EGLFS con un backend eglfs_kms_egldevice
Este backend, utilizado habitualmente en dispositivos Tegra, es similar al backend KMS/DRM mencionado anteriormente, salvo que se basa en las extensiones EGLDevice y EGLStream en lugar de en GBM.
Para obtener detalles técnicos sobre este enfoque, consulta esta presentación.
A partir de Qt 5.7, este backend comparte gran parte de su implementación interna con el backend basado en GBM. Esto significa que se admiten múltiples pantallas y la configuración avanzada a través de ` QT_QPA_EGLFS_KMS_CONFIG `. Sin embargo, algunos ajustes, como ` hwcursor ` y ` pbuffers `, no son aplicables.
Por defecto, el backend elegirá automáticamente la capa EGL correcta para el plano predeterminado de cada salida. Cuando sea necesario, esto se puede anular estableciendo la variable de entorno QT_QPA_EGLFS_LAYER_INDEX en el índice de la capa deseada. Este enfoque no admite actualmente múltiples salidas, por lo que su uso debe limitarse a sistemas con una sola pantalla. Para ver qué capas están disponibles y depurar posibles problemas de arranque, activa la categoría de registro « qt.qpa.eglfs.kms ».
En algunos casos, puede ser necesario establecer el modo de vídeo al iniciar la aplicación, incluso cuando la pantalla indique que la resolución deseada ya está configurada. Normalmente esto se optimiza automáticamente, pero si la pantalla permanece apagada, prueba a establecer la variable de entorno ` QT_QPA_EGLFS_ALWAYS_SET_MODE ` en un valor distinto de cero y vuelve a iniciar la aplicación.
Para configurar el comportamiento del objeto EGLStream utilizado por el backend, utilice la variable de entorno QT_QPA_EGLFS_STREAM_FIFO_LENGTH. Esto supone que el sistema de destino es compatible con KHR_stream_fifo. Por defecto, el flujo funciona en modo «mailbox». Para cambiar al modo FIFO, establezca un valor igual o superior a 1. El valor especifica el número máximo de fotogramas que puede contener el flujo.
En algunos sistemas puede ser necesario seleccionar un plano de superposición específico a través de un conector predefinido. El mero hecho de forzar un índice de capa mediante QT_QPA_EGLFS_LAYER_INDEX no realiza la configuración del plano y, por lo tanto, no es adecuado por sí solo. En su lugar, en estos casos especiales, utilice las variables de entorno QT_QPA_EGLFS_KMS_CONNECTOR_INDEX y QT_QPA_EGLFS_KMS_PLANE_INDEX. Cuando se establezcan, solo se utilizarán el conector y el plano especificados; todas las demás salidas se ignorarán. El backend se encargará de seleccionar la capa EGL que corresponda al plano deseado y de configurar dicho plano.
Entrada táctil en sistemas con varias pantallas en KMS/DRM
Las pantallas táctiles requieren consideraciones adicionales en sistemas con múltiples pantallas, ya que los eventos táctiles deben dirigirse a la pantalla virtual correcta, lo que exige una asignación adecuada entre las pantallas táctiles y las salidas de pantalla.
La correspondencia se realiza a través del archivo de configuración JSON especificado en QT_QPA_EGLFS_KMS_CONFIG y descrito en las secciones anteriores. Cuando una propiedad touchDevice está presente en un elemento de la matriz outputs, el valor se trata como un nodo de dispositivo y el dispositivo táctil se asocia a la salida de pantalla en cuestión.
Por ejemplo, suponiendo que nuestra pantalla táctil tiene un nodo de dispositivo de /dev/input/event5 y es una pantalla táctil integrada en el monitor conectado vía HDMI como pantalla secundaria, la siguiente configuración garantiza la traducción correcta de los eventos táctiles (y del ratón sintetizado):
{
"device": "drm-nvdc",
"outputs": [
{
"name": "HDMI1",
"touchDevice": "/dev/input/event5",
"virtualIndex": 1
},
{
"name": "DP1",
"virtualIndex": 0
}
]
}Nota: En caso de duda, habilita el registro tanto del subsistema gráfico como del de entrada estableciendo la variable de entorno QT_LOGGING_RULES=qt.qpa.*=true antes de iniciar la aplicación. Esto ayudará a identificar los nodos de dispositivo de entrada correctos y puede revelar problemas de configuración de salida que, de otro modo, resultarían difíciles de depurar.
Nota: A partir de Qt 5.14, lo anterior solo es compatible con los backends evdevtouch y libinput. Otras variantes seguirán enviando los eventos a la pantalla principal. Para forzar el uso de evdevtouch en sistemas donde hay varios backends de entrada disponibles, establece la variable de entorno QT_QPA_EGLFS_NO_LIBINPUT en 1.
EGLFS con otros backends
Otros backends, que suelen basarse en dirigirse directamente al framebuffer o a una API de composición a través de la implementación de EGL del fabricante, suelen ofrecer un soporte limitado o nulo para múltiples pantallas. En placas basadas en i.MX6 con GPU Vivante, se puede utilizar la variable de entorno QT_QPA_EGLFS_FB para especificar el framebuffer al que dirigirse, de forma similar a linuxfb. En la Raspberry Pi, se puede utilizar la variable de entorno QT_QPA_EGLFS_DISPMANX_ID para especificar la pantalla a la que se debe enviar la salida. El valor corresponde a una de las constantes DISPMANX_ID_; consulte la documentación de Dispmanx. Ten en cuenta que estos métodos, a diferencia de KMS/DRM, no suelen permitir la salida a varias pantallas desde la misma aplicación. Como alternativa, también pueden estar disponibles variables de entorno específicas del controlador o parámetros del núcleo para controlar el framebuffer utilizado. Consulta la documentación de la placa embebida.
Memoria de vídeo
Los sistemas con una cantidad fija de memoria de vídeo dedicada pueden requerir una atención especial antes de ejecutar aplicaciones Qt basadas en Qt Quick o en clases como QOpenGLWidget. La configuración por defecto puede resultar insuficiente para este tipo de aplicaciones, especialmente cuando se muestran en una pantalla de alta resolución (por ejemplo, Full HD). En este caso, pueden empezar a fallar de forma inesperada. Se recomienda asegurarse de que haya al menos 128 MB de memoria de la GPU disponibles. Para los sistemas que no tienen una cantidad fija de memoria reservada para la GPU, esto no supone ningún problema.
linuxfb
Utilice el parámetro del complemento « fb » para especificar el dispositivo de búfer de fotogramas que se va a utilizar.
Manejadores de señales de Unix y estado de la consola
Los complementos de plataforma orientados a la consola, como eglfs y linuxfb, instalan de forma predeterminada controladores de señales para capturar la interrupción (SIGINT), la suspensión y la reanudación (SIGTSTP, SIGCONT) y la terminación (SIGTERM). De este modo, el teclado, el cursor del terminal y, posiblemente, otros aspectos del estado gráfico pueden restaurarse cuando la aplicación finaliza o se suspende debido a kill, Ctrl+C o Ctrl+Z. (Aunque la finalización o la suspensión mediante el teclado solo es posible cuando se ha establecido QT_QPA_ENABLE_TERMINAL_KEYBOARD; véase «Entradas en un dispositivo Linux embebido»). Sin embargo, en algunos casos, la captura de SIGINT puede resultar indeseable, ya que puede entrar en conflicto con la depuración remota, por ejemplo. Por lo tanto, se proporciona la variable de entorno QT_QPA_NO_SIGNAL_HANDLER para desactivar toda la gestión de señales integrada.
Los controladores se instalan al inicializarse el complemento de la plataforma, sustituyendo cualquier configuración que la aplicación hubiera establecido anteriormente.
Advertencia: En SIGINT y SIGTERM se restaura el estado de la consola y, a continuación, el proceso se cierra mediante _exit(). No se ejecutan los controladores de « atexit() », los destructores estáticos ni el código de cierre de Qt, y los datos almacenados en el búfer no se vacían. Por lo tanto, systemctl stop o un simple kill cierran la aplicación de forma inmediata. Una aplicación que necesite conservar el estado en SIGTERM debe establecer QT_QPA_NO_SIGNAL_HANDLER e instalar su propio controlador, encargándose también de restaurar el estado de la consola.
El estado de la consola solo se restaura en estas rutas y al apagar el sistema de forma normal. No se restaura cuando el proceso se detiene debido a SIGSEGV, SIGABRT o std::terminate(). Con linuxfb, que también cambia el terminal virtual al modo gráfico, una aplicación que se cierre de forma anómala puede dejar la consola local en blanco y sin responder a las entradas del teclado hasta que se reinicie el dispositivo. En dispositivos en los que esa consola sea la única vía de recuperación local, proporcione una alternativa, como una consola serie o un watchdog que reinicie el dispositivo. Utilice QT_QPA_PRESERVE_CONSOLE_STATE para mantener sin cambios la configuración del cursor de la terminal y el apagado de la pantalla, y la opción « nographicsmodeswitch » de linuxfb para omitir el cambio al modo gráfico.
Consideraciones de seguridad
Los complementos de plataforma descritos en esta página se ejecutan sin un sistema de ventanas y, por lo tanto, asumen responsabilidades que normalmente corresponderían a un compositor o a un servidor de pantalla. En esta sección se describe en qué confían y qué se espera que controle el creador del dispositivo. Véase también el modelo de seguridad compartida de Qt.
La configuración es contenido de confianza
El comportamiento de los complementos de plataforma integrados —qué nodos de dispositivo se abren, qué complemento de integración de dispositivos se carga en el proceso, cómo se asignan las coordenadas táctiles a las pantallas— viene determinado por las variables de entorno, por el archivo de configuración JSON de KMS/DRM y por los archivos opcionales de mapa de teclas y atlas de cursor. Todos ellos constituyen contenido de confianza: se espera que estén fijos cuando se compila la imagen del dispositivo y que, a partir de entonces, sean controlados por el creador del dispositivo. Qt comprueba que estén bien formados, pero no realiza ninguna validación adicional, y no están destinados a ser expuestos al usuario final del dispositivo de ninguna forma.
Hay dos entradas que merecen especial atención:
QT_QPA_EGLFS_INTEGRATIONno restringe los complementos que se pueden cargar. El backend solicitado solo se coloca al principio de la lista de candidatos; si no se inicializa, se siguen probando los backends restantes por orden. En un sistema en el que haya varios complementos de integración de dispositivos, un backend que la implementación no haya especificado puede acabar cargándose e inicializando el hardware. Incluye únicamente los backends que el dispositivo necesite.- La calibración táctil y la rotación, ya se configuren mediante
QT_QPA_LIBINPUT_TOUCH_MATRIX, los parámetrosevdev,rotate,invertxyinverty, o la asignacióntouchDeviceen el archivo de configuración JSON, determinan dónde se registra una pulsación. Una configuración incorrecta implica que el usuario active un control distinto al que ha tocado, lo cual, en una interfaz hombre-máquina, constituye una característica de seguridad. Considéralos parte de la configuración verificada del dispositivo, en lugar de un ajuste configurable in situ.
Los dispositivos de entrada no se filtran
La detección de dispositivos de Qt abre todos los nodos /dev/input/event* que coincidan con la clase de capacidad que busca y, cuando hay soporte para libudev, también abre los dispositivos que aparecen posteriormente mientras la aplicación está en ejecución. No existe una lista de dispositivos permitidos, ni un filtro por fabricante o producto, ni la noción de un conjunto esperado de dispositivos. Los eventos de todos los dispositivos aceptados se envían a la aplicación como si procedieran del dispositivo previsto; la aplicación no puede distinguirlos.
Por lo tanto, restringir qué dispositivos existen y quién puede leerlos es tarea del creador del dispositivo, y se lleva a cabo a nivel del núcleo, de udev y de los permisos del sistema de archivos, en lugar de en la aplicación. Una aplicación Qt a la que no se le permita leer /dev/input/* no lee ninguna entrada. Además:
- Al nombrar los dispositivos explícitamente en
QT_QPA_EVDEV_MOUSE_PARAMETERS,QT_QPA_EVDEV_KEYBOARD_PARAMETERSyQT_QPA_EVDEV_TOUCHSCREEN_PARAMETERSse omite el proceso de detección, fijando así el conjunto de dispositivos que utiliza la aplicación. - Al pasar
grab=1, la aplicación obtiene acceso exclusivo a un dispositivo, lo cual merece la pena tener en cuenta en un dispositivo que ejecute una única aplicación. - Ten en cuenta
disable-zap; consulta «Entradas en un dispositivo Linux embebido».
Las pantallas son entradas no fiables
El bloque EDID que una pantalla envía a través del conector lo proporciona cualquier dispositivo conectado, ya sea un monitor, un adaptador, un conmutador KVM o un dispositivo de captura, y se vuelve a analizar en cada evento de conexión en caliente. En eglfs con el backend KMS/DRM, los valores que contiene llegan a la aplicación a través de ` QScreen::manufacturer()`, ` QScreen::model()`, ` QScreen::serialNumber()` y el tamaño físico notificado. Considéralos como valores influenciados por factores externos: no los utilices como identificadores y ten en cuenta que pueden aparecer en los registros. El tamaño físico se puede anular con QT_QPA_EGLFS_PHYSICAL_WIDTH y QT_QPA_EGLFS_PHYSICAL_HEIGHT, o mediante la salida correspondiente en el archivo de configuración JSON.
Dependencias en tiempo de ejecución
Los complementos de la plataforma integrada son adaptadores ligeros sobre bibliotecas proporcionadas por el paquete de soporte de la placa o la distribución, no por Qt, y que se ejecutan en el proceso de la aplicación. Dependiendo de la configuración, estos son:
- eglfs: EGL y, dependiendo del backend, GBM, Mesa y el controlador de la GPU, o una implementación de EGL del proveedor;
libdrmpara los backends KMS/DRM. - vkkhrdisplay: el cargador de Vulkan y los controladores de Vulkan instalados.
- linuxfb: la interfaz «
fbdev» del núcleo, o «libdrm» cuando se establece «QT_QPA_FB_DRM». - Entrada:
libinput,libudevymtdev;xkbcommon, que además lee los datos del mapa de teclas del sistema; otslib, cuyo propio archivo de configuración determina qué módulos de filtro se cargan y, por lo tanto, cuáles Qt no puede seleccionar ni enumerar.
Inclúyalos en la lista de materiales de software del dispositivo y manténgalos actualizados, y configure Qt únicamente con los backends que el dispositivo utilice realmente. Para los dispositivos nuevos, es preferible utilizar libinput en lugar del antiguo tslib.
Fuentes
Qt suele utilizar fontconfig para proporcionar acceso a las fuentes del sistema. Si fontconfig no está disponible, Qt recurrirá a QBasicFontDatabase. En este caso, las aplicaciones de Qt buscarán las fuentes en el directorio lib/fonts de Qt. Qt detectará automáticamente las fuentes prerenderizadas y las fuentes TrueType. Este directorio se puede anular configurando la variable de entorno QT_QPA_FONTDIR.
Para obtener más información sobre los formatos compatibles, consulta «Qt for Embedded Linux Fonts».
Nota: Qt ya no incluye ninguna fuente en el directorio lib/fonts. Esto significa que corresponde a la plataforma (la imagen del sistema) proporcionar las fuentes necesarias.
Complementos de plataforma para sistemas de ventanas en dispositivos Linux embebidos
XCB
Este es el complemento X11 que se utiliza en plataformas Linux de escritorio habituales. En algunos entornos embebidos que proporcionan X y los archivos de desarrollo necesarios para xcb, este complemento funciona exactamente igual que en un ordenador de sobremesa convencional.
Nota: En algunos dispositivos no hay compatibilidad con EGL ni OpenGL disponible bajo X, ya que la implementación de EGL no es compatible con Xlib. En este caso, el complemento XCB se compila sin compatibilidad con EGL, lo que significa que Qt Quick 2 u otras aplicaciones basadas en OpenGL no funcionan con este complemento de plataforma. No obstante, se puede seguir utilizando para ejecutar aplicaciones con renderizado por software (basadas, por ejemplo, en QWidget ).
Como norma general, no se recomienda el uso de XCB en dispositivos integrados. Es probable que complementos como eglfs ofrezcan un mejor rendimiento y aceleración por hardware.
Wayland
Wayland es un sistema de ventanas ligero; o, más precisamente, es un protocolo que permite a los clientes comunicarse con un servidor de pantalla.
Qt Wayland proporciona un complemento de plataforma « wayland » que permite a las aplicaciones Qt conectarse a un compositor de Wayland.
Para más detalles, consulta Wayland y Qt.
Directrices para mejorar el rendimiento
Utiliza el renderizado por hardware siempre que sea posible
Cuando el rendimiento sea fundamental para su aplicación, evite el uso de módulos de Qt que dependan del renderizado por software. En su lugar, opte por módulos que utilicen el renderizado por hardware, siempre que sea posible.
Sigue las prácticas recomendadas para Qt Quick
Siga las mejores prácticas para QML y Qt Quick, especialmente en lo que respecta a la inclusión de la API de CMake para QML, de modo que qmllint, el compilador de scripts QML (qmlsc) y el compilador de tipos QML (qmltc) estén disponibles. Además, es preferible escribir QML declarativo y reducir al mínimo el uso de JavaScript. Para obtener más información sobre cómo el uso excesivo de JavaScript puede afectar al rendimiento, consulta «Consideraciones y sugerencias sobre el rendimiento de QML».
Utiliza imágenes/texturas y efectos de sombreado en lugar del tipo «Canvas» de QML
Para dibujar elementos de interfaz de usuario personalizados, utiliza imágenes/texturas y efectos de sombreado. No utilices el tipo « Canvas » de QML. Los sombreados requieren aceleración por hardware (GPU).
Utiliza ` Qt Quick ` en lugar de Qt Widgets
Con ` Qt Quick`, es posible utilizar tanto backends acelerados por hardware como renderizados por software. Para interfaces de usuario complejas, no se recomienda utilizar ` Qt Widgets ` en dispositivos embebidos, ya que siempre utilizará un backend de software.
Esto conlleva algunas ventajas e inconvenientes:
- El uso del motor QML y de Qt Quick conlleva una sobrecarga inicial.
- Si tu interfaz de usuario es muy sencilla y rara vez se actualiza, puede que funcione más rápido si se implementa utilizando widgets en lugar de QML.
- Si tu interfaz de usuario se beneficia de animaciones, smooth scrolling, y scaling, rendering effects o 3D, necesitarás aceleración por GPU y, por lo tanto, Qt Quick.
Elige una resolución adecuada al tamaño de tu interfaz de usuario
Debes tener cuidado con las resoluciones más altas. Las resoluciones de 720p y superiores pueden reducir el rendimiento.
Utiliza un tipo «QML Window» como elemento raíz de tu aplicación
Utiliza un « Window » como elemento raíz de tu aplicación con el fondo de la aplicación color.
El motivo es que el componente «Window» tiene una propiedad de color que actúa como un borrado del búfer. Representar el fondo utilizando un « Rectangle » a pantalla completa como elemento raíz de la aplicación Item provocaría una llamada de dibujo adicional. Para algunos backends de RHI esto puede ser lo mismo, pero hay una diferencia entre una llamada « glClear » y dibujar un cuadrilátero. En la mayoría de los casos, una sola imagen opaca puede que no tenga un gran impacto en el rendimiento, pero si se utilizara un valor alfa en el color de ese elemento, podría observarse un impacto significativo en el rendimiento.
Temas relacionados
© 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.