Driver de Video GBM

October 1, 2018 @AreaScout Juegos, ODROID-XU4, Tutoriales 0

Esta es una guía para instalar los drivers de espacio de usuario para activar GBM y compilar emuladores de juegos retro. En primer lugar, mostraremos el uso de la librería de espacio de usuario que activa Mali GBM. Veremos qué tal funciona y para qué se puede usar. Utilizaremos la pantalla ODROID-VU5A para mostrar algunos ejemplos.

Instalaremos una imagen mínima de Ubuntu 18.04 para XU4 y prepararemos el sistema para usar el driver Mali GBM. Como resultado, PPSSPP podrá ejecutarse para emular perfectamente los juegos sin ningún tipo de problema. El video que muestra GoW - Chains of Olympus en ODROID-XU4 lo puedes encontrar en https://youtu.be/QegJlwflkZk.

Instalar la imagen

Descarga la imagen: ubuntu-18.04-4.14-minimal-odroid-xu4-20180531.img.xz desde https://odroid.in/ubuntu_18.04lts/. Extrae y escribe la imagen en el soporte de arranque, utilizando la guía de la wiki de Hardkernel.

Arranca el ODROID-XU4 usando el soporte de arranque y usa las credenciales de inicio de sesión:

Nombre de Usuario: root Contraseña: odroid

Actualiza el software del sistema usando los comandos: 

$ apt update && apt full-upgrade -y
Actualiza el software del sistema usando los comandos: 
$ apt-get install mali-x11 libx11-dev libsm-dev libxext-dev git cmake mercurial libudev-dev libdrm-dev zlib1g-dev pkg-config libasound2-dev alsa-utils htop bc ifupdown2 net-tools libssl1.0-dev mlocate bluez libfreetype6-dev libgbm-dev
Agrega el usuario odroid y añade el ID del usuario a los grupos: 
$ adduser odroid usermod -aG Sudo,adm,audio,operator,input,video,tty,staff,games,users, plugdev,netdev,bluetooth,disk odroid
Inicia sesión con el usuario recientemente creado: 
$ su - odroid
Activa el prompt de color: 
$ sed -i '1iforce_color_prompt=yes' ~/.bashrc
$ su odroid
Cambia el driver de pantalla mali-x11 por el que activa GBM. Normalmente, esto es relativamente fácil de hacer simplemente actualizando eglplatform.h, que es multiplataforma (es decir, fbdev x11 y GBM). Sin embargo, necesitamos también actualizar otras cabeceras 
$ cd /usr/include/EGL
$ sudo rm eglplatform.h
$ sudo wget https://www.khronos.org/registry/EGL/api/EGL/eglplatform.h
$ cd /usr/include/GLES2
$ sudo rm *
$ sudo wget \
https://www.khronos.org/registry/OpenGL/api/GLES2/gl2platform.h
$ sudo wget https://www.khronos.org/registry/OpenGL/api/GLES2/gl2.h
$ sudo wget https://www.khronos.org/registry/OpenGL/api/GLES2/gl2ext.h
$ cd /usr/include/GLES3
$ sudo rm *
$ sudo wget https://www.khronos.org/registry/OpenGL/api/GLES3/gl3.h
$ sudo wget https://www.khronos.org/registry/OpenGL/api/GLES3/gl31.h
$ sudo wget https://www.khronos.org/registry/OpenGL/api/GLES3/gl32.h
$ sudo wget \
https://www.khronos.org/registry/OpenGL/api/GLES3/gl3platform.h
Ahora consigue el nuevo driver binario: 
$ cd ~
$ wget http://deb.odroid.in/bigmali.tar
$ tar xf bigmali.tar libmali.so
$ sudo mv libmali.so /usr/lib/arm-linux-gnueabihf/mali-egl/.
Añade un enlace simbólico que falta: 
$ sudo ln -s /usr/lib/arm-linux-gnueabihf/mali-egl/libmali.so \
/usr/lib/arm-linux-gnueabihf/libGLESv1_CM.so.1
Agrega un nuevo directorio, abre el editor vi con el archivo /usr/local/lib/pkgconfig/gbm.pc: 
$ sudo mkdir /usr/local/lib/pkgconfig
$ sudo vi /usr/local/lib/pkgconfig/gbm.pc
Añade la siguiente sección en el nuevo archivo: 
prefix=/usr/local
exec_prefix=${prefix}
includedir=${prefix}/include
libdir=${exec_prefix}/lib
Name: libgbm
Description: A small gbm implementation
Version: 19.0.0
Cflags: -I${includedir}
Libs: -L${libdir} -lgbm
Guarda y cierra vi. Añade enlaces simbólicos para libgbm: 
$ cd /usr/local/lib/
$ sudo ln -s /usr/lib/arm-linux-gnueabihf/mali-egl/libmali.so libgbm.so
$ sudo ln -s libgbm.so libgbm.so.19
$ sudo ln -s libgbm.so.19 libgbm.so.19.0.0
$ sudo ldconfig
Coge gbm.h y borra el de mesa: 
$ cd /usr/include
$ sudo rm gbm.h
$ sudo wget -O gbm.h https://pastebin.com/raw/5QUd011t
Descarga SDL2, compílalo e instálalo: 
$ cd ~
$ hg clone http://hg.libsdl.org/SDL SDL2
$ cd SDL2
$ ./configure --disable-video-opengl --enable-video-kmsdrm
Una vez finalizada la configuración, deberías ver esta línea: 
Video drivers : dummy x11(dynamic) kmsdrm(dynamic) opengl_es1 opengl_es2 vulkan
Ahora tenemos que editar SDL_config.h para abrir permanentemente nuestro libgbm.so.19 en lugar de libgbm.so.1 de Mesa. Compílalo e instálalo: 
$ sed -i -e 's/libgbm.so.1/libgbm.so.19/g' include/SDL_config.h
$ make -j7
$ sudo make install
Una vez completada la compilación podemos hacer pruebas:

$ cd test $ ./configure $ make -j7 $ ./testgles2

Deberías ver un cubo giratorio, espera unos segundos y salte con la tecla ESC. Si estás utilizando VU5A, observarás algo similar a esto lo cual indica que es demasiado lento: 

INFO: 56.89 frames per second
Deberías alcanzar los 60 fps, sino tendremos problemas con los emuladores. Si intentan mantener solo 60 fps y no lo consiguen, entonces es que realmente se ralentizarán mucho las cosas. Podremos seguir observando los videos de introducción de los juegos PPSSPP.

Compilando el Kernel para  >60fps en VU5A

Tenemos que parchear el kernel para conseguir más de 56 fps de procesamiento. Hasta que se publiquen los cambios necesarios en el kernel principal, tendremos que hacerlo por nuestra cuenta.

El reloj de píxeles y, probablemente, algunos valores de sincronización H o V de la configuración HDMI PHY no son los correctos para la pantalla VU5A. Los detalles los puedes encontrar en https://goo.gl/CVJYS6. Hardkernel tomó el más cercano, pero lo eligieron para estar por debajo de los 60 fps. Para la emulación es mejor elegir el que esté por encima de los 60 fps, de modo que al final tendremos una velocidad de fotogramas de 64 fps.

Asegúrate de tener suficiente espacio en el almacenamiento del sistema y luego coge la fuente del kernel. Seleccionaremos la configuración de HDMI PHI del siguiente reloj de píxeles más alto, en realidad lo que hay dentro de esta configuración HDMI PHY es desconocido para el público. Hemos preguntado a varios desarrolladores, pero nadie ha sabido darme una respuesta, solo que en el kernel 3.10 hay un pequeño código para cambiar esta configuración de 32 bytes. Así que solo se conocen unos cuantos bytes, aunque no cambian la velocidad de refresco. 

$ git clone https://github.com/hardkernel/linux.git
$ cd linux
$ wget -O VU5A.patch https://pastebin.com/raw/aWEYArWL
$ patch -p1 < VU5A.patch

$ make odroidxu4_defconfig
$ make -j7
$ sudo cp arch/arm/boot/zImage /media/boot/.
$ sudo cp arch/arm/boot/dts/exynos5422-odroidxu4.dtb /media/boot/.
$ sudo make modules_install
Reinicia y testea el valor de fps nuevamente: 
$ cd SDL2/test
$ ./testgles2
Ahora deberías ver algo como esto: 
INFO: 64.01 frames per second
Ahora compilaremos PPSSPP y luego RetroArch con el back-end GBMS KMSDRM, inclusive libretro

Compilando PPSSPP

PPSSPP es un emulador de PSP para Android.

Coge el código fuente y aplica un parche necesario: 

$ cd ~
$ git clone --recursive https://github.com/hrydgard/ppsspp.git
FFmpeg debe compilarse antes de compilar el binario PPSSPP. Los binarios pre-compilados son todos para puntos flotantes débiles y necesitamos hardfp: 
$ ./linux_armhf.sh
$ cd ..
Antes de que empecemos a compilar, debemos convertir nuestra copia de /usr/include/GLES2/gl2ext.h en una específica del proveedor deshabilitando el uso de GL_EXT_buffer_storage. Se crea un archivo de copia de seguridad gl2ext.h.back. Nuestra librería Mali no incluye/exporta esa función, así que no podemos definirla. 
$ sudo sed -i.bak '/^\#ifndef GL_EXT_buffer_storage$/,/^$/d' /usr/include/GLES2/gl2ext.h
Es posible que quieras configurar el sistema para usar solo 4 núcleos en FFmpeg con el fin de realizar pequeños ajustes y experimentar. He observado que FFmpeg con subprocesamiento no funciona muy bien cuando se eligen todos los núcleos con HMP (cambiando las tareas más exigentes de LITTLE CPU a BIG CPU). Para esto, puede editar el archivo Core/HW/MediaEngine.cpp en la línea número 475, y modificarla para usar solo 4 núcleos (mejor cambiar de 4 LITTLE a 4 BIG en lugar de usar los 8 núcleos).

No obstante, esto ha sido analizado en Moonlight con archivos de video 1080p de juegos por streaming. Los archivos de video PPSSPP no son tan grandes, de modo que, tal vez no requieran tanta CPU, así que puede afectar muy poco o prácticamente nada: 

av_dict_set(&opt, "threads", "4", 0);
Ahora, necesitamos generar el Makefile. 
$ cmake -DUSING_EGL=OFF -DUSING_GLES2=ON -DUSE_FFMPEG=YES -DUSE_SYSTEM_FFMPEG=NO.

Empieza a compilar el binario:
$ make -j7
Si estás utilizando VU5A, ahora contarás con la función de pantalla táctil en el menú y también podrás activar “los controles táctiles en pantalla” si quieres. Puedes ver un video en https://youtu.be/QegJlwflkZk?t=374. Ahora puedes marcar tu PPSSPP emulada con una única región generando la correspondiente configuración regional. En mi caso, utilicé de_AT: 
$ sudo locale-gen de_AT.UTF-8
$ sudo update-locale LANG=de_AT.UTF-8
Algunos juegos pueden usarla para el idioma dentro del juego. La descarga https://goo.gl/BhHLxm contiene mi configuración para GoW, incluidos algunos reemplazos de texturas para Star Wars, The Clone Wars y Star Wars, y The Force Unleashed. Estos juegos son jugables.

El directorio de configuración de PPSSPP debería verse así: 

odroid@odroid:~$ tree -d .config/ppsspp/
.config/ppsspp/
└── PSP
├── PPSSPP_STATE
├── SAVEDATA
│ ├── ULES01284SAVE00
│ └── ULES01376SYSDATA
├── SYSTEM
│ └── CACHE
└── TEXTURES
├── ULES00981
└── ULES01284

10 directories

Compilar y configurar RetroArch

Puedes ver un video de esto en https://youtu.be/6Ewgov7_TXM. Además de RetroArch, necesitamos un pequeño parche que nos evita tener el menú con sólo un fondo negro: 

$ git clone https://github.com/libretro/RetroArch.git
$ cd RetroArch
$ wget -O retro.patch https://pastebin.com/raw/1SCeb8EG
$ patch -p1 < retro.patch 
$ ./configure --enable-opengles3 --enable-opengles --enable-neon \ --enable-floathard --enable-freetype 
$ make -j7 
$ sudo make install 
$ retroarch
Aplica algunas configuraciones útiles. Simplemente es una sugerencia para que configures RetroArch, una vez instalado ya no tendrás que seguir este tutorial. Actualiza los recursos (iconos, imágenes de fondo y esas cosas). Puedes encontrar la información necesaria en los siguientes menús: 
MainMenu -> Online Updater -> Update Assets
Te sugerimos que también actualices estos paquetes: 
Core Info Files, Joypad Profiles, Database, GLSL Shaders
Además, puedes usar Core Updater para conseguir algunos emuladores. A continuación, activa la Configuración avanzada: 
Settings -> User Interface -> Show Advanced Settings -> ON
Activa Threaded Video, notarás que mejorará bastante la emulación: 
Settings -> Video -> Threaded Video -> ON
Activa el contador de FPS, es útil ver lo rápido que se ejecuta la emulación, especialmente cuando estás configurando cosas: 
Settings -> Onscreen Display -> Onscreen Notifications -> Display Framerate -> ON

Settings -> Onscreen Display -> Onscreen Notifications -> Show frame count on FPS Display -> OFF

Settings -> Driver -> Audio Driver -> alsathread
y si está utilizando VU5A: 
Settings -> Onscreen Display -> Onscreen Notifications -> Notification size -> 18

Settings -> Onscreen Display -> Onscreen Notifications -> Notification X position -> 0.010

Settings -> Onscreen Display -> Onscreen Notifications -> Notification Y position -> 0.010
Si ya tienes juegos instalados en tu ODROID-XU4, búscalos utilizando Import Content -> Scan Directory y selecciona la carpeta donde almacenas tus juegos para que RetroArch los escanee. Aparecerán en la parte derecha del menú después de un tiempo.

Compilar y configura Versatile Commodore Emulator

Puedes ver un video de esto en: https://youtu.be/ItkppnXWd9U

Primero instalaremos Cice libretro y luego mame libretro.

Instalar los prerrequisitos: 

$ sudo apt-get install bison
Descarga el código fuente y aplica el parche para máquinas VIC-II Commodore si quieres. Esto eliminará los margenes de los modelos de máquina C64 y C128, los juegos se ven mejor sin él. Este es un modo rápido de hacerlo. Una mejor forma sería añadirlo a la configuración de libretro.

Si un juego sobrepasa los márgenes, no funcionará y el sistema probablemente se comporte de forma indebida, aunque son pocos los juegos los que se acercan a los márgenes. 

$ git clone https://github.com/libretro/vice-libretro.git
$ cd vice-libretro
$ wget -O noborder.patch https://pastebin.com/raw/VwtSDj50
$ patch -p1 < noborder.patch
Empieza a compilar una máquina Commodore. Los tipos de máquina válidos son: 
x128, x64, x64sc, x64dtv, x64scpu, xplus4, xvic, xcbm5x0, xcbm2, xpet
Debes añadir la variable EMUTYPE seguida del tipo de máquina que quieres compilar. Si no agregas esta variable, entonces la x64 (C64) será el tipo de máquina por defecto. 
$ make EMUTYPE=x64 -f Makefile.libretro -j7
Si deseas compilar más de un tipo de máquina, no olvides ejecutar el comando clean sobre el proyecto, de lo contrario el núcleo no funcionará: 
$ make EMUTYPE=x64 -f Makefile.libretro -j7 clean

Configuración de Retroarch

Copia el binario en la carpeta cores del RetroArch: 

$ cp vice_x64_libretro.so ~/.config/retroarch/cores/.
Inicia RetroArch y selecciona el núcleo vice - inicia el núcleo sin juego o con él. Presiona el botón Guía en tu mando o F1 en el teclado y desplázate hacia abajo hasta las Opciones, entra y desactiva DriveTrueEmulaton-> OFF. Te llevará algo de tiempo cargar un juego y configurar Controller0Type en el joystick.

También puede habilitar una relación de aspecto de 16:10. Es un buen término medio entre 4: 3 y 16: 9. 

Settings -> Video -> Aspect Ratio -> 16:10
Con el botón de Inicio puedes activar la configuración GUI nuklear (el botón Select debe pulsarse una vez para activar el raton) desde allí puede elegir el Joyport C64, cpu de la máquina, tipo de sid y mucho más. El teclado en pantalla se activa con el botón x (diseño de Xbox)

Compilar y configurar Reicast Core - un emulador de Dreamcast

El video lo pueden encontrar en https://youtu.be/j0jEUcQx-vM. Descarga la fuente y aplica un parche como de costumbre: 

$ cd ~
$ git clone https://github.com/libretro/reicast-emulator.git
$ wget -O xu4.patch https://pastebin.com/raw/pfVjnVs3
$ patch -p1 < xu4.patch
$ platform=odroid ARCH=arm make -j7
$ strip reicast_libretro.so
$ cp reicast_libretro.so ~/.config/retroarch/cores/.
Primero necesitas alguna bios para NAOMI y Dreamcast. Unos buenos enlaces para conseguirlas y usarlas son  https://goo.gl/a5JbMT y https://docs.libretro.com/library/reicast/. Si deseas conocer la suma de comprobación md5 del archivo bios de NAOMI, puede consultar el archivo de información: 
/home/odroid/.config/retroarch/cores/reicast_libretro.info
Dentro de un juego, abre el menú RetroArch y dirígete a las opciones básicas. Encuentra la siguiente configuración y cámbiala a los siguientes valores, que son los más importantes para lograr una velocidad decente: 
reicast_framerate = "normal"
reicast_enable_rttb = "enabled"
reicast_threaded_rendering = "enabled"
Para comentarios, preguntas y sugerencias, visita el post original en https://forum.odroid.com/viewtopic.php?f=98&t=32173.

Be the first to comment

Leave a Reply