Rockchip RGA IM2D API: Hardwarefähigkeiten, Schnittstellen und Beispiele

Vollständige technische Kapitel von Rockchip RGA IM2D API V2.2.7 (82 chinesische und 79 englische Seiten). Für ArmSoM müssen RGA-Version des Board-SoC, SDK/BSP, passende librga-/Kerneltreiber und Speicher-/Formatgrenzen geprüft werden. Unterstützung aller Funktionen auf allen Boards wird nicht behauptet. Keine einheitliche Kernelversion ist angegeben; Kapitel 2 enthält Treiberkompatibilität. Keine ArmSoM-Hardwarevalidierung wurde durchgeführt. Leistungswerte sind theoretische Herstellerangaben; Beispiele und Logs keine ArmSoM-Messungen.

Quellunklarheiten bleiben erhalten: impyramind/impyramid und imfilp/imflip; imcvtcolorTask wird als Verschiebung beschrieben; §5.3.12 nennt IM_ALPHA_BLEND_DST, §3.15 SRC_OVER. Die OSD-Tabelle ordnet interne/externe Steuerung EXTERNAL/INTERNAL zu, offenbar entgegen den Namen. Schreibweisen bule, RK_FORMA_A8, RK1103B, RK1108 erfordern SDK-Prüfung. Die Hardwaretabelle ist rechts abgeschnitten: sichtbares 3 (by pa… für RGA3 bleibt ohne erratene Ergänzung erhalten.

ArmSoM Docs · Rockchip librga

1. Übersicht

RGA (Raster Graphic Acceleration Unit) ist ein unabhängiger 2D-Hardwarebeschleuniger für Punkt-/Linienzeichnung, Skalierung, Rotation, bitBlt und Alpha-Blending.

1.1 Auslegungsspezifikationen

Hinweis:

1) Die Pixelanzahl pro Takt ist theoretisch. Die tatsächliche Leistung hängt von Bandbreite, Hardwaretakt und weiteren Faktoren ab; die Tabelle dient nur als Referenz.

2) Zusätzlich zur minimalen Eingangsauflösung müssen x, y, width und height des tatsächlichen Operationsrechtecks jedes Kanals mindestens 2 sein.

3) Der adressierbare Speicher hängt von der IOMMU-Breite ab. Beispielsweise kann RGA mit 32-Bit-IOMMU nur physischen Speicher im Bereich 0–4G adressieren.

1.2 Unterstützte Bildformate

Pixelformatkonvertierung: BT.601/BT.709/BT.2020 (BT.2020 nur mit RGA3). Dithering.

Hinweis:

1) RK_FORMAT_YCbCr_400 verwendet nur den Y-Kanal von YUV, meist für 256 (2^8) Graustufen. Bei RGB/YUV-Konvertierung ist die Farbraumeinstellung zu beachten. Für alle 256 Graustufen bei der Konvertierung full range konfigurieren.

2) RK_FORMAT_Y4 verwendet nur den Y-Kanal von YUV und dithert auf 4 Bit, meist für 16 (2^4) Graustufen. Es gelten dieselben Farbraumhinweise wie für RK_FORMAT_YCbCr_400. RK_FORMAT_Y8 ähnelt RK_FORMAT_Y4 und hat ebenfalls nur 4 gültige Bits: die oberen vier enthalten gültige Daten, die unteren vier nicht.

1.3 Bildformatausrichtung

Hinweis:

1) Ausrichtungsformel: lcm(bpp, byte_stride * 8) / pixel_stride.

2) Enthält eine Plattform mehrere Hardwareversionen, setzt librga die strengsten Ausrichtungsanforderungen durch, um die Hardwareauslastung zu gewährleisten.

2. Versionen

Die RGA-Bibliothek librga.so aktualisiert ihre Version nach Regeln für neue Funktionen, Kompatibilität und Fehlerkorrekturen. Mehrere Abfragemethoden helfen bei der Entscheidung, ob die Bibliothek zur Umgebung passt. Einzelheiten zu Änderungen stehen in CHANGLOG.md im Quellwurzelverzeichnis.

2.1 librga-API-Version

2.1.1 Versionsformat und Erhöhungsregeln

2.1.1.1 Versionsformat

major.minor.revision_[build]

Beispiel:

1.0.0_[0]

2.1.1.2 Erhöhungsregeln

2.1.2 Version abfragen

2.1.2.1 Abfrage mit strings

Beispiel für 64-Bit-Android R:

:/# strings vendor/lib64/librga.so |grep rga_api |grep version
rga_api version 1.0.0_[0]

2.1.2.2 Logausgabe

Beim ersten RGA-API-Aufruf jedes Prozesses wird die Version protokolliert.

rockchiprga: rga_api version 1.0.0_[0]

2.1.2.3 API-Abfrage

Die folgende API fragt Code-, Build- und RGA-Hardwareversion ab. Details stehen im Abschnitt zu Anwendungsschnittstellen.

querystring(RGA_VERSION);

Zeichenfolgenformat:

RGA_api version : v1.0.0_[0]
RGA version : RGA_2_Enhance

2.1.2.4 Eigenschaftsabfrage

Eigenschaftsabfragen werden nur unter Android unterstützt und sind erst wirksam, nachdem ein Prozess RGA aufgerufen und die Eigenschaft gesetzt hat.

:/# getprop |grep rga
[vendor.rga_api.version]: [1.0.0_[0]]

2.2 Treiberversion

librga greift über den Treiber auf RGA zu. Die Treiberversion muss von der verwendeten librga-Version unterstützt werden.

2.2.1 Versionsformat und Erhöhungsregeln

2.2.1.1 Versionsformat

<driver_name>: v major.minor.revision

Beispiele:

RGA2 Device Driver: v2.1.0
RGA multicore Device Driver: v1.2.23

2.2.1.2 Erhöhungsregeln

2.2.2 Version abfragen

2.2.2.1 Bootlog-Abfrage

Nach dem Start die RGA-Treiberinitialisierung mit folgendem Befehl abfragen. Manche älteren Treiber geben keine Version aus; die Methode funktioniert daher nicht mit allen Versionen.

dmesg |grep rga

Beispiel:

[ 2.382393] rga3_core0 fdb60000.rga: Adding to iommu group 2
[ 2.382651] rga: rga3_core0, irq = 33, match scheduler
[ 2.383058] rga: rga3_core0 hardware loaded successfully, hw_version:3.0.76831.
[ 2.383121] rga: rga3_core0 probe successfully
[ 2.383687] rga3_core1 fdb70000.rga: Adding to iommu group 3
[ 2.383917] rga: rga3_core1, irq = 34, match scheduler
[ 2.384313] rga: rga3_core1 hardware loaded successfully, hw_version:3.0.76831.
[ 2.384412] rga: rga3_core1 probe successfully
[ 2.384893] rga: rga2, irq = 35, match scheduler
[ 2.385238] rga: rga2 hardware loaded successfully, hw_version:3.2.63318.
[ 2.385257] rga: rga2 probe successfully
[ 2.385455] rga_iommu: IOMMU binding successfully, default mapping core[0x1]
[ 2.385586] rga: Module initialized. v1.2.23

Hier ist v1.2.23 die Treiberversion.

2.2.2.2 Debugknoten-Abfrage

Die Version lässt sich über Debug-Knoten des Treibers abfragen. Fehlen die folgenden Knoten, unterstützt der laufende Treiber diese Abfrage nicht. Für einen Kernel mit der normalerweise aktivierten Option CONFIG_ROCKCHIP_RGA_DEBUG_FS:

cat /sys/kernel/debug/rkrga/driver_version

Für einen Kernel mit aktivierter ROCKCHIP_RGA_PROC_FS:

cat /proc/rkrga/driver_version

cat /sys/kernel/debug/rkrga/driver_version
RGA multicore Device Driver: v1.2.23

RGA multicore Device Driver bezeichnet den Treibernamen, v1.2.23 die Version 1.2.23. Es läuft somit RGA multicore Device Driver Version 1.2.23 (meist multi_rga driver genannt).

cat /sys/kernel/debug/rkrga/driver_version
RGA2 Device Driver: v2.1.0

RGA2 Device Driver bezeichnet den Treibernamen, v2.1.0 die Version 2.1.0. Es läuft somit RGA2 Device Driver Version 2.1.0 (meist rga2 driver genannt).

2.3 Versionsbeziehungen

Vor der Verwendung von RGA die Kompatibilität der Laufzeitumgebung prüfen. Die folgende Tabelle zeigt gängige Zuordnungen von librga- und Treiberversionen.

3. Anwendungsschnittstellen

Die RGA-Unterstützungsbibliothek heißt librga.so. Sie konfiguriert struct rga_info für 2D-Operationen und kapselt häufige Funktionen in einer benutzerfreundlicheren API. Die Definitionen orientieren sich an OpenCV/MATLAB, um den Lernaufwand zu verringern. RGA query liefert Hardwareversion, maximale Ein-/Ausgabeauflösungen und Formate zur Behandlung von Kompatibilitätsunterschieden. Vor der Verarbeitung befüllt wrapbuffer_T struct rga_buffer_t mit Pufferinformationen einschließlich Auflösung und Format. improcess führt kombinierte Operationen anhand vordefinierter usage-Flags aus. Nicht in einem Durchlauf ausführbare Operationen können als RGA-Job zusammengefasst und gemeinsam zur sequenziellen Treiberausführung eingereicht werden.

3.1 Übersicht

Diese Bibliothek stellt folgende APIs bereit. Asynchroner Modus wird nur von der C++-Implementierung unterstützt.

• querystring: Hardwareversion und unterstützte Funktionen des RGA im aktuellen SoC als String abfragen.
• imcheckHeader: Unterschiede zwischen aktueller Header- und librga-Version prüfen.
• importbuffer_T: Externen Speicher (dma_fd, virtuelle oder physische Adresse) in den RGA-Treiber importieren, damit Hardware schnell auf physisch zusammenhängenden oder nicht zusammenhängenden Speicher zugreifen kann.
• releasebuffer_handle: Treiberreferenzen und Abbildungen externer Puffer aufheben.
• wrapbuffer_handle: Einen Bildpuffer schnell in rga_buffer_t kapseln.
• imbeginJob: Einen RGA-Bildverarbeitungsjob erstellen.
• imendJob: Einen RGA-Job übermitteln und ausführen.
• imcancelJob: Einen RGA-Job abbrechen und löschen.
• imcopy: RGA für schnelle Bildkopie aufrufen.
• imcopyTask: Schnelle Bildkopie zu einem RGA-Bildjob hinzufügen.
• imresize: RGA für schnelle Bildskalierung aufrufen.
• imresizeTask: Schnelle Bildskalierung zu einem RGA-Bildjob hinzufügen.
• impyramind: RGA für schnelle Bildpyramidenverarbeitung (Quellschreibweise) aufrufen.
• imcrop: RGA für schnelle Bildzuschnitt aufrufen.
• imcropTask: Schnelle Bildzuschnitt zu einem RGA-Bildjob hinzufügen.
• imtranslate: RGA für schnelle Bildverschiebung aufrufen.
• imtranslateTask: Schnelle Bildverschiebung zu einem RGA-Bildjob hinzufügen.
• imcvtcolor: RGA für schnelle Bildformatkonvertierung aufrufen.
• imcvtcolorTask: Schnelle Bildformatkonvertierung zu einem RGA-Bildjob hinzufügen.
• imrotate: RGA für schnelle Bildrotation aufrufen.
• imrotateTask: Schnelle Bildrotation zu einem RGA-Bildjob hinzufügen.
• imflip: RGA für schnelle Bildspiegelung aufrufen.
• imflipTask: Schnelle Bildspiegelung zu einem RGA-Bildjob hinzufügen.
• imblend: RGA für schnelle Zweikanalkomposition aufrufen.
• imblendTask: Schnelle Zweikanalkomposition zu einem RGA-Bildjob hinzufügen.
• imcomposite: RGA für schnelle Dreikanalkomposition aufrufen.

• imcompositeTask: Schnelle Dreikanalkomposition zu einem RGA-Bildjob hinzufügen.

• imcolorkey: RGA für schnelle Farbschlüsselverarbeitung aufrufen.
• imcolorkeyTask: Schnelle Farbschlüsselverarbeitung zu einem RGA-Bildjob hinzufügen.
• imosd: RGA für schnelle OSD-Textüberlagerung aufrufen.
• imosdTask: Schnelle OSD-Textüberlagerung zu einem RGA-Bildjob hinzufügen.
• imquantize: RGA für schnelle NN-Vorverarbeitung (Quantisierung) aufrufen.
• imquantizeTask: Schnelle NN-Vorverarbeitung (Quantisierung) zu einem RGA-Bildjob hinzufügen.
• imrop: RGA für schnelle Rasteroperationen aufrufen.
• imropTask: Schnelle Rasteroperationen zu einem RGA-Bildjob hinzufügen.
• imfill: RGA für schnelle Bildfüllung aufrufen.
• imfillTask: Schnelle Bildfüllung zu einem RGA-Bildjob hinzufügen.
• imfillArray: RGA für schnelle mehrfache Bildfüllung aufrufen.
• imfillTaskArray: Schnelle mehrfache Bildfüllung zu einem RGA-Bildjob hinzufügen.
• imrectangle: RGA für schnelle gleichmäßige Rechteckrahmen aufrufen.
• imrectangleTask: Schnelle gleichmäßige Rechteckrahmen zu einem RGA-Bildjob hinzufügen.
• imrectangleArray: RGA für schnelle mehrere gleichmäßige Rechteckrahmen aufrufen.
• imrectangleTaskArray: Schnelle mehrere gleichmäßige Rechteckrahmen zu einem RGA-Bildjob hinzufügen.
• immakeBorder: RGA für schnelle Rechteckrahmen aufrufen.
• immosaic: RGA für schnelle Mosaikmaskierung aufrufen.
• immosaicTask: Schnelle Mosaikmaskierung zu einem RGA-Bildjob hinzufügen.
• immosaicArray: RGA für schnelle Mosaikmaskierung aufrufen.
• immosaicTaskArray: Schnelle Mosaikmaskierung zu einem RGA-Bildjob hinzufügen.
• improcess: RGA für schnelle kombinierte Bildverarbeitung aufrufen.
• improcessTask: Schnelle kombinierte Bildverarbeitung zu einem RGA-Bildjob hinzufügen.
• imcheck: Parametergültigkeit und Hardwareunterstützung prüfen.
• imsync: Abschluss im asynchronen Modus synchronisieren.
• imconfig: Standardeinstellungen zum aktuellen Threadkontext hinzufügen.

Die API-Unterstützung in unterschiedlichen Umgebungen folgt:

Legende: √ unterstützt; × nicht unterstützt; / nicht zutreffend.

3.2 RGA-Version und Unterstützung abfragen

3.2.1 querystring

const char* querystring(int name);

RGA-Grundinformationen sowie unterstützte Auflösungen und Formate abfragen.

Gibt einen String mit RGA-Eigenschaften zurück.

3.3 Headerversion prüfen

3.3.1 imcheckHeader

IM_API IM_STATUS imcheckHeader(im_api_version_t header_version = RGA_CURRENT_API_HEADER_VERSION);

Unterschiede zwischen verwendeter Header- und librga-Version prüfen.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.4 Bildpuffervorverarbeitung

3.4.1 importbuffer_T

Für von RGA zu verarbeitenden externen Speicher bildet importbuffer_T die physischen Pufferadressen im Treiber ab und ermittelt die zugehörigen Adressinformationen für spätere stabile und schnelle RGA-Aufrufe.

Die Leistung hängt vom Puffertyp ab: physical address > fd > virtual address. Im Allgemeinen wird fd empfohlen.

IM_API rga_buffer_handle_t importbuffer_fd(int fd, int size);
IM_API rga_buffer_handle_t importbuffer_virtualaddr(void *va, int size);
IM_API rga_buffer_handle_t importbuffer_physicaladdr(uint64_t pa, int size);

IM_API rga_buffer_handle_t importbuffer_fd(int fd, int width, int height, int format);
IM_API rga_buffer_handle_t importbuffer_virtualaddr(void *va, int width, int height, int format);
IM_API rga_buffer_handle_t importbuffer_physicaladdr(uint64_t pa, int width, int height, int format);

IM_API rga_buffer_handle_t importbuffer_fd(int fd, im_handle_param_t *param);
IM_API rga_buffer_handle_t importbuffer_virtualaddr(void *va, im_handle_param_t *param);
IM_API rga_buffer_handle_t importbuffer_physicaladdr(uint64_t pa, im_handle_param_t *param);

IM_API rga_buffer_handle_t importbuffer_GraphicBuffer_handle(buffer_handle_t hnd);
IM_API rga_buffer_handle_t importbuffer_GraphicBuffer(sp<GraphicBuffer> buf);
IM_API rga_buffer_handle_t importbuffer_AHardwareBuffer(AHardwareBuffer *buf);

Gibt ein Speicherhandle rga_buffer_handle_t zurück.

3.4.2 releasebuffer_handle

Nach der RGA-Verarbeitung externen Speichers releasebuffer_handle mit dessen handle aufrufen, um Pufferzuordnung und -bindung sowie die entsprechenden Treiberressourcen freizugeben.

IM_API IM_STATUS releasebuffer_handle(rga_buffer_handle_t handle);

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.4.3 wrapbuffer_handle

IM2D-Parameter für Quell- und Zielbilder unterstützen mehrere Typen und beschreiben Speicher, Format, Breite und Höhe. Vor der Bildoperation wandelt wrapbuffer_handle diese Angaben in die gemeinsame Struktur rga_buffer_t für die Benutzer-API um.

rga_buffer_t wrapbuffer_handle(rga_buffer_handle_t handle,
                               int width,
                               int height,
                               int format,
                               int wstride = width,
                               int hstride = height);

Gibt rga_buffer_t zur Bildbeschreibung zurück.

3.5 Bildjob erstellen

3.5.1 imbeginJob

IM_API im_job_handle_t imbeginJob(uint64_t flags = 0);

Einen RGA-Bildverarbeitungsjob erstellen und dessen Handle zurückgeben. job_handle dient zum Hinzufügen/Entfernen von Operationen und zum Einreichen/Ausführen des Jobs.

Gibt ein Jobhandle im_job_handle_t zurück.

3.6 Bildjob übermitteln

3.6.1 imendJob

IM_API IM_STATUS imendJob(im_job_handle_t job_handle,
                          int sync_mode = IM_SYNC,
                          int acquire_fence_fd = 0,
                          int *release_fence_fd = NULL);

Einen erstellten RGA-Bildverarbeitungsjob einreichen und ausführen. Nach Abschluss werden seine Ressourcen automatisch gelöscht.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.7 Bildjob abbrechen

3.7.1 imcancelJob

IM_API IM_STATUS imcancelJob(im_job_handle_t job_handle);

Einen erstellten RGA-Bildverarbeitungsjob abbrechen und löschen.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.8 Bildkopie

3.8.1 imcopy

IM_STATUS imcopy(const rga_buffer_t src,
                 rga_buffer_t dst,
                 int sync = 1,
                 int *release_fence_fd = NULL);

Ein Bild einmalig schnell vom src-Kanalpuffer in den dst-Kanalpuffer kopieren.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.8.2 imcopyTask

IM_API IM_STATUS imcopyTask(im_job_handle_t job_handle,
                            const rga_buffer_t src,
                            rga_buffer_t dst);

Über job_handle eine Operation für Bildkopie zum angegebenen Job hinzufügen. Verwendung wie bei imcopy.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.9 Skalierung und Bildpyramiden

3.9.1 imresize

IM_STATUS imresize(const rga_buffer_t src,
                   rga_buffer_t dst,
                   double fx = 0,
                   double fy = 0,
                   int interpolation = INTER_LINEAR,
                   int sync = 1,
                   int *release_fence_fd = NULL);

Die Zielabmessungen über dst oder das gewünschte Verhältnis über fx/fy festlegen. Werden beide konfiguriert, haben die aus fx/fy berechneten Abmessungen Vorrang.

Nur RGA1/RGA1 plus unterstützen eine konfigurierbare interpolation; bei anderer Hardware den Skalierungsalgorithmus im TRM nachsehen. Mit fx/fy werden Abmessungen von Formaten mit Ausrichtungsanforderungen, etwa YUV, nach unten ausgerichtet. Das kann das erwartete Skalierungsergebnis verändern.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.9.2 impyramid

IM_STATUS impyramid (const rga_buffer_t src,
                     rga_buffer_t dst，
                     IM_SCALE direction)

Pyramidenskalierung: abhängig von direction Breite und Höhe gemeinsam halbieren oder verdoppeln.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.9.3 imresizeTask

IM_API IM_STATUS imresizeTask(im_job_handle_t job_handle,
                              const rga_buffer_t src,
                              rga_buffer_t dst,
                              double fx = 0,
                              double fy = 0,
                              int interpolation = 0);

Über job_handle eine Operation für Bildskalierung zum angegebenen Job hinzufügen. Verwendung wie bei imresize.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.10 Bildzuschnitt

3.10.1 imcrop

IM_STATUS imcrop(const rga_buffer_t src,
                 rga_buffer_t dst,
                 im_rect rect,
                 int sync = 1,
                 int *release_fence_fd = NULL);

Das Bild auf den durch Rect angegebenen Bereich und dessen Größe zuschneiden.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.10.2 imcropTask

IM_API IM_STATUS imcropTask(im_job_handle_t job_handle,
                            const rga_buffer_t src,
                            rga_buffer_t dst,
                            im_rect rect);

Über job_handle eine Operation für Bildzuschnitt zum angegebenen Job hinzufügen. Verwendung wie bei imcrop.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.11 Bildverschiebung

3.11.1 imtranslate

IM_STATUS imtranslate(const rga_buffer_t src,
                      rga_buffer_t dst,
                      int x,
                      int y,
                      int sync = 1,
                      int *release_fence_fd = NULL);

Das Bild zu (x, y) verschieben. src und dst müssen gleiche Breite und Höhe besitzen; überstehende Teile werden abgeschnitten.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.11.2 imtranslateTask

IM_API IM_STATUS imtranslateTask(im_job_handle_t job_handle,
                                 const rga_buffer_t src,
                                 rga_buffer_t dst,
                                 int x,
                                 int y);

Über job_handle eine Operation für Bildverschiebung zum angegebenen Job hinzufügen. Verwendung wie bei imtranslate.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.12 Bildformatkonvertierung

3.12.1 imcvtcolor

IM_STATUS imcvtcolor(rga_buffer_t src,
                     rga_buffer_t dst,
                     int sfmt,
                     int dfmt,
                     int mode = IM_COLOR_SPACE_DEFAULT,
                     int sync = 1,
                     int *release_fence_fd = NULL);

Das Bildformat konvertieren. Die Unterstützung hängt vom SoC ab; siehe Formatübersicht. Formate über rga_buffer_t oder getrennt über sfmt/dfmt festlegen. Bei YUV/RGB-Farbraumkonvertierung wählt mode den Farbraum; Standard ist BT.601 limited range.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.12.2 imcvtcolorTask

IM_API IM_STATUS imcvtcolorTask(im_job_handle_t job_handle,
                                rga_buffer_t src,
                                rga_buffer_t dst,
                                int sfmt,
                                int dfmt,
                                int mode = IM_COLOR_SPACE_DEFAULT);

Über job_handle eine Operation für Bildverschiebung (Quellwortlaut) zum angegebenen Job hinzufügen. Verwendung wie bei imcvtcolor.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.13 Bildrotation

3.13.1 imrotate

IM_STATUS imrotate(const rga_buffer_t src,
                   rga_buffer_t dst,
                   int rotation,
                   int sync = 1,
                   int *release_fence_fd = NULL);

Bilder um 90, 180 oder 270 Grad drehen.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.13.2 imrotateTask

IM_API IM_STATUS imrotateTask(im_job_handle_t job_handle,
                              const rga_buffer_t src,
                              rga_buffer_t dst,
                              int rotation);

Über job_handle eine Operation für Bildrotation zum angegebenen Job hinzufügen. Verwendung wie bei imrotate.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.14 Bildspiegelung

3.14.1 imfilp

IM_STATUS imflip (const rga_buffer_t src,
                  rga_buffer_t dst,
                  int mode,
                  int sync = 1,
                  int *release_fence_fd = NULL);

Bilder horizontal oder vertikal spiegeln.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.14.2 imflipTask

IM_API IM_STATUS imflipTask(im_job_handle_t job_handle,
                            const rga_buffer_t src,
                            rga_buffer_t dst,
                            int mode);

Über job_handle eine Operation für Bildspiegelung zum angegebenen Job hinzufügen. Verwendung wie bei imflip.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.15 Bildkomposition

3.15.1 imblend/imcomposite

IM_STATUS imblend(const rga_buffer_t fg_image,
                  rga_buffer_t bg_image,
                  int mode = IM_ALPHA_BLEND_SRC_OVER,
                  int sync = 1,
                  int *release_fence_fd = NULL);

Die Zweikanalkomposition verwendet A+B -> B: Vordergrund srcA und Hintergrund dst werden nach dem eingestellten Alpha-Modell gemischt, das Ergebnis geht an dst. Ohne Konfiguration gilt src-over.

IM_STATUS imcomposite(const rga_buffer_t fg_image,
                      const rga_buffer_t bg_image,
                      rga_buffer_t output_image,
                      int mode = IM_ALPHA_BLEND_SRC_OVER,
                      int sync = 1,
                      int *release_fence_fd = NULL);

Die RGA-Dreikanalkomposition verwendet A+B -> C: Vordergrund srcA und Hintergrund srcB werden nach dem konfigurierten Modell alphagemischt, das Ergebnis wird in dst geschrieben. Standard ist src-over. In beiden Kompositionsarten wählt mode das Porter-Duff-Modell. Definitionen:

• S: Quell-/Vordergrundbild.
• D: Ziel-/Hintergrundbild.
• R: Ergebnis.
• c: RGB-Farbkomponenten von RGBA. Porter-Duff verwendet vormultiplizierte Farben: Originalfarbe mal Alpha. Falls noch nicht vormultipliziert, Xc = Xc * Xa ausführen.
• a: Alpha-/Transparenzkomponente von RGBA.
• f: Faktor für Farbe oder Alpha.

Die Kernformeln berechnen Ergebnisfarbe = Quellfarbe × Quellfaktor + Zielfarbe × Zielfaktor; Ergebnisalpha wird entsprechend berechnet. RGA unterstützt folgende Modelle:

Rc = Sc * Sf + Dc * Df;
Ra = Sa * Sf + Da * Df;

SRC:
Sf = 1, Df = 0;
[Rc,Ra] = [Sc,Sa];
DST:
Sf = 0, Df = 1;
[Rc,Ra] = [Dc,Da];
SRC_OVER:
Sf = 1, Df = (1 - Sa);
[Rc,Ra] = [ Sc + (1 - Sa) * Dc, Sa + (1 - Sa) * Da ];
DST_OVER:
Sf = (1 - Da), Df = 1;

[Rc,Ra] = [ Sc * (1 - Da) + Dc, Sa * (1 - Da) + Da ] ;

Komposition zwischen YUV-Bildern wird nicht unterstützt. dst bei imblend und srcB bei imcomposite dürfen kein YUV verwenden.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.15.2 imblendTask/imcompositeTask

IM_API IM_STATUS imblendTask(im_job_handle_t job_handle,
                             const rga_buffer_t fg_image,
                             rga_buffer_t bg_image,
                             int mode = IM_ALPHA_BLEND_SRC_OVER);

Über job_handle eine A+B -> B-Komposition zum Job hinzufügen. Verwendung wie imblend; Standardmischmodus ist src-over.

IM_API IM_STATUS imcompositeTask(im_job_handle_t job_handle,
                                 const rga_buffer_t fg_image,
                                 const rga_buffer_t bg_image,
                                 rga_buffer_t output_image,
                                 int mode = IM_ALPHA_BLEND_SRC_OVER);

Über job_handle eine A+B -> C-Komposition hinzufügen. Verwendung wie imcomposite; Standard ist src-over. YUV-zu-YUV-Komposition wird nicht unterstützt: dst bei imblend und srcB bei imcomposite dürfen kein YUV verwenden.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.16 Farbschlüssel

3.16.1 imcolorkey

IM_STATUS imcolorkey(const rga_buffer_t src,
                     rga_buffer_t dst,
                     im_colorkey_range range,
                     int mode = IM_ALPHA_COLORKEY_NORMAL,
                     int sync = 1,
                     int *release_fence_fd = NULL);

Color Key setzt bei der Vorverarbeitung die Alpha-Komponente der Quellpixel auf null, deren nichttransparente Farbwerte die Schlüsselbedingung erfüllen. Anschließend wird die Quelle mit dem Ziel alphagemischt. Die Filterung gilt nur für den festgelegten Farbbereich in src; das Ergebnis wird auf dst gelegt. IM_ALPHA_COLORKEY_NORMAL löscht Alpha innerhalb des Bereichs, IM_ALPHA_COLORKEY_INVERTED außerhalb. Standard ist IM_ALPHA_COLORKEY_NORMAL.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.16.2 imcolorkeyTask

IM_API IM_STATUS imcolorkeyTask(im_job_handle_t job_handle,
                                const rga_buffer_t fg_image,
                                rga_buffer_t bg_image,
                                im_colorkey_range range,
                                int mode = IM_ALPHA_COLORKEY_NORMAL);

Über job_handle Color Key zum Job hinzufügen. Verwendung wie imcolorkey; Standardmodus ist IM_ALPHA_COLORKEY_NORMAL.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.17 OSD-Textüberlagerung

3.17.1 imosd

IM_API IM_STATUS imosd(const rga_buffer_t osd,
                       const rga_buffer_t bg_image,
                       const im_rect osd_rect,
                       im_osd_t *osd_config,
                       int sync = 1,
                       int *release_fence_fd = NULL);

OSD (On-Screen Display) legt Text über Videobilder und unterstützt Helligkeitsstatistik des Textes sowie automatische Farbinvertierung.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.17.2 imosdTask

IM_API IM_STATUS imosdTask(im_job_handle_t job_handle,
                           const rga_buffer_t osd,
                           const rga_buffer_t bg_image,
                           const im_rect osd_rect,
                           im_osd_t *osd_config);

Über job_handle OSD-Verarbeitung zum angegebenen Job hinzufügen. Verwendung wie imosd.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.18 NN-Vorverarbeitung (Quantisierung)

3.18.1 imquantize

IM_STATUS imquantize(const rga_buffer_t src,
                     rga_buffer_t dst,
                     rga_nn_t nn_info,
                     int sync = 1,
                     int *release_fence_fd = NULL);

Derzeit nur auf RV1126 / RV1109 unterstützt. Bei der NN-Vorverarbeitung können offset und scale für jeden der drei RGB-Kanäle getrennt eingestellt werden. Formel:

dst = 【(src + offset) * scale 】

Parameterbereiche:

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.18.2 imquantizeTask

IM_API IM_STATUS imquantizeTask(im_job_handle_t job_handle,
                                const rga_buffer_t src,
                                rga_buffer_t dst,
                                im_nn_t nn_info);

Über job_handle Bildquantisierung zum angegebenen Job hinzufügen. Verwendung wie imquantize.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.19 Rasteroperationen (ROP)

3.19.1 imrop

IM_STATUS imrop(const rga_buffer_t src,
                rga_buffer_t dst,
                int rop_code,
                int sync = 1,
                int *release_fence_fd = NULL);

Eine ROP-Operation auf zwei Bildern ausführen.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.19.2 imropTask

IM_API IM_STATUS imropTask(im_job_handle_t job_handle,
                           const rga_buffer_t src,
                           rga_buffer_t dst,
                           int rop_code);

Über job_handle ROP-Bildverarbeitung zum angegebenen Job hinzufügen. Verwendung wie imrop.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.20 Farbfüllung und Rahmenzeichnung

3.20.1 imfill

IM_STATUS imfill(rga_buffer_t dst,
                 im_rect rect,
                 int color,
                 int sync = 1,
                 int *release_fence_fd = NULL);

Den angegebenen Bereich rect mit Farbe füllen. color gibt RGBA an, von hohen zu niedrigen Bits A, B, G, R; beispielsweise Rot: color = 0x000000ff. Breite und Höhe von rect müssen jeweils mindestens 2 sein.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.20.2 imfillArray

IM_API IM_STATUS imfillArray(rga_buffer_t dst,
                             im_rect *rect_array,
                             int array_size,
                             uint32_t color,
                             int sync = 1,
                             int *release_fence_fd = NULL);

Mehrere Bildbereiche nacheinander mit Farbe füllen. color gibt RGBA an, von hohen zu niedrigen Bits A, B, G, R; beispielsweise Rot: color = 0x000000ff. Breite und Höhe von rect müssen jeweils mindestens 2 sein.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.20.3 imfillTask

IM_API IM_STATUS imfillTask(im_job_handle_t job_handle,
                            rga_buffer_t dst,
                            im_rect rect,
                            uint32_t color);

Über job_handle Bildfüllung zum Job hinzufügen. Verwendung wie imfill. Breite und Höhe von rect müssen jeweils mindestens 2 sein.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.20.4 imfillTaskArray

IM_API IM_STATUS imfillTaskArray(im_job_handle_t job_handle,
                                 rga_buffer_t dst,
                                 im_rect *rect_array,
                                 int array_size,
                                 uint32_t color);

Über job_handle Farbfüllung mehrerer Bereiche zum Job hinzufügen. Verwendung wie imfillArray. Breite und Höhe von rect müssen jeweils mindestens 2 sein.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.20.5 imrectangle

IM_API IM_STATUS imrectangle(rga_buffer_t dst,
                             im_rect rect,
                             uint32_t color,
                             int thickness,
                             int sync = 1,
                             int *release_fence_fd = NULL);

Mit color einen Rahmen der Stärke thickness um rect zeichnen, das den äußeren Rand angibt. Bei negativem thickness wird ein ausgefülltes Rechteck erzeugt. color gibt RGBA an, von hohen zu niedrigen Bits A, B, G, R; beispielsweise Rot: color = 0x000000ff. Breite und Höhe von rect müssen jeweils mindestens 2 sein.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.20.6 imrectangleArray

IM_API IM_STATUS imrectangleArray(rga_buffer_t dst,
                                  im_rect *rect_array,
                                  int array_size,
                                  uint32_t color,
                                  int thickness,
                                  int sync = 1,
                                  int *release_fence_fd = NULL);

Nacheinander mit color Rahmen der Stärke thickness um mehrere rect-Bereiche zeichnen, die die äußeren Ränder angeben. Bei negativem thickness werden ausgefüllte Rechtecke erzeugt. color gibt RGBA an, von hohen zu niedrigen Bits A, B, G, R; beispielsweise Rot: color = 0x000000ff. Breite und Höhe von rect müssen jeweils mindestens 2 sein.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.20.7 imrectangleTask

IM_API IM_STATUS imrectangleTask(im_job_handle_t job_handle,
                                 rga_buffer_t dst,
                                 im_rect rect,
                                 uint32_t color,
                                 int thickness);

Über job_handle rechteckige Bildrahmen zum Job hinzufügen. Verwendung wie imrectangle. Breite und Höhe von rect müssen jeweils mindestens 2 sein.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.20.8 imrectangleTaskArray

IM_API IM_STATUS imrectangleTaskArray(im_job_handle_t job_handle,
                                      rga_buffer_t dst,
                                      im_rect *rect_array,
                                      int array_size,
                                      uint32_t color,
                                      int thickness);

Über job_handle mehrere rechteckige Bildrahmen zum Job hinzufügen. Verwendung wie imrectangleArray. Breite und Höhe von rect müssen jeweils mindestens 2 sein.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.20.9 immakeBorder

IM_API IM_STATUS immakeBorder(rga_buffer_t src,
                              rga_buffer_t dst,
                              int top,
                              int bottom,
                              int left,
                              int right,
                              int border_type,
                              int value = 0,
                              int sync = 1,
                              int acquir_fence_fd = -1,
                              int *release_fence_fd = NULL);

Dem Eingangsbild Ränder mit top/bottom/left/right Pixeln hinzufügen und das Ergebnis in den Zielpuffer schreiben. Jeder Wert top/bottom/left/right muss mindestens 2 betragen.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.21 Bildmosaik

3.21.1 immosaic

IM_API IM_STATUS immosaic(const rga_buffer_t image,
                          im_rect rect,
                          int mosaic_mode,
                          int sync = 1,
                          int *release_fence_fd = NULL);

Den angegebenen Bildbereich mit einer Mosaikmaske abdecken.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.21.2 immosaicArray

IM_API IM_STATUS immosaicArray(const rga_buffer_t image,
                               im_rect *rect_array,
                               int array_size,
                               int mosaic_mode,
                               int sync = 1,
                               int *release_fence_fd = NULL);

Mehrere Bildbereiche nacheinander mit Mosaikmasken abdecken.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.21.3 immosaicTask

IM_API IM_STATUS immosaicTask(im_job_handle_t job_handle,
                              const rga_buffer_t image,
                              im_rect rect,
                              int mosaic_mode);

Über job_handle Mosaikmaskierung zum angegebenen Job hinzufügen. Verwendung wie immosaic.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.21.4 immosaicTaskArray

IM_API IM_STATUS immosaicTaskArray(im_job_handle_t job_handle,
                                   const rga_buffer_t image,
                                   im_rect *rect_array,
                                   int array_size,
                                   int mosaic_mode);

Über job_handle Mosaikmaskierung mehrerer Bildbereiche zum angegebenen Job hinzufügen. Verwendung wie immosaicArray.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.22 Bildverarbeitung

3.22.1 improcess

IM_STATUS improcess(rga_buffer_t src,
                    rga_buffer_t dst,
                    rga_buffer_t pat,
                    im_rect srect,
                    im_rect drect,
                    im_rect prect,
                    int acquire_fence_fd,
                    int *release_fence_fd,
                    im_opt_t *opt,
                    int usage);

Funktion für kombinierte RGA-Bildoperationen. Die anderen APIs bauen darauf auf; improcess ermöglicht komplexere Kombinationen. Bildoperationen werden über usage konfiguriert, das wie folgt definiert ist:

typedef enum {
    /* Rotation */
    IM_HAL_TRANSFORM_ROT_90     = 1 << 0,
    IM_HAL_TRANSFORM_ROT_180    = 1 << 1,
    IM_HAL_TRANSFORM_ROT_270    = 1 << 2,
    IM_HAL_TRANSFORM_FLIP_H     = 1 << 3,
    IM_HAL_TRANSFORM_FLIP_V     = 1 << 4,
    IM_HAL_TRANSFORM_FLIP_H_V   = 1 << 5,
    IM_HAL_TRANSFORM_MASK       = 0x3f,
    /*
     * Blend
     * Additional blend usage, can be used with both source and target configs.
     * If none of the below is set, the default "SRC over DST" is applied.
     */
    IM_ALPHA_BLEND_SRC_OVER     = 1 << 6,     /* Default, Porter-Duff "SRC over DST" */
    IM_ALPHA_BLEND_SRC          = 1 << 7,     /* Porter-Duff "SRC" */
    IM_ALPHA_BLEND_DST          = 1 << 8,     /* Porter-Duff "DST" */
    IM_ALPHA_BLEND_SRC_IN       = 1 << 9,     /* Porter-Duff "SRC in DST" */
    IM_ALPHA_BLEND_DST_IN       = 1 << 10,    /* Porter-Duff "DST in SRC" */
    IM_ALPHA_BLEND_SRC_OUT      = 1 << 11,    /* Porter-Duff "SRC out DST" */
    IM_ALPHA_BLEND_DST_OUT      = 1 << 12,    /* Porter-Duff "DST out SRC" */
    IM_ALPHA_BLEND_DST_OVER     = 1 << 13,    /* Porter-Duff "DST over SRC" */
    IM_ALPHA_BLEND_SRC_ATOP     = 1 << 14,    /* Porter-Duff "SRC ATOP" */
    IM_ALPHA_BLEND_DST_ATOP     = 1 << 15,    /* Porter-Duff "DST ATOP" */
    IM_ALPHA_BLEND_XOR          = 1 << 16,    /* Xor */
    IM_ALPHA_BLEND_MASK         = 0x1ffc0,

    IM_ALPHA_COLORKEY_NORMAL    = 1 << 17,
    IM_ALPHA_COLORKEY_INVERTED  = 1 << 18,
    IM_ALPHA_COLORKEY_MASK      = 0x60000,

    IM_SYNC                     = 1 << 19,
    IM_ASYNC                    = 1 << 26,
    IM_CROP                     = 1 << 20,    /* Unused */
    IM_COLOR_FILL               = 1 << 21,
    IM_COLOR_PALETTE            = 1 << 22,
    IM_NN_QUANTIZE              = 1 << 23,
    IM_ROP                      = 1 << 24,
    IM_ALPHA_BLEND_PRE_MUL      = 1 << 25,
} IM_USAGE;

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.22.2 improcessTask

IM_API IM_STATUS improcessTask(im_job_handle_t job_handle,
                               rga_buffer_t src,
                               rga_buffer_t dst,
                               rga_buffer_t pat,
                               im_rect srect,
                               im_rect drect,
                               im_rect prect,
                               im_opt_t *opt_ptr,
                               int usage);

Über job_handle kombinierte Bildverarbeitung zum angegebenen Job hinzufügen. Verwendung wie improcess.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.23 Parameterprüfung

3.23.1 imcheck

IM_API IM_STATUS imcheck(const rga_buffer_t src, const rga_buffer_t dst,
                         const im_rect src_rect, const im_rect dst_rect,
                         const int mode_usage);
IM_API IM_STATUS imcheck_composite(const rga_buffer_t src, const rga_buffer_t dst, const rga_buffer_t pat,
                                   const im_rect src_rect, const im_rect dst_rect, const im_rect pat_rect,
                                   const int mode_usage);

Nach der Konfiguration der RGA-Jobparameter prüft diese Schnittstelle deren Gültigkeit und Unterstützung durch die aktuelle Hardware.

Diese Schnittstelle nur während Entwicklung und Fehlersuche verwenden, um Leistungseinbußen durch wiederholte Prüfungen zu vermeiden.

Gibt bei Erfolg IM_STATUS_NOERROR zurück, andernfalls einen negativen Fehlercode.

3.24 Synchronisierung

3.24.1 imsync

IM_STATUS imsync(int fence_fd);

Im asynchronen Modus diese Schnittstelle mit dem zurückgegebenen release_fence_fd aufrufen, um auf den Abschluss zu warten. sync = 0 aktiviert bei anderen APIs asynchrone Aufrufe, ähnlich OpenGL glFlush. Ein anschließendes imsync entspricht der Wirkung von glFinish.

Gibt bei Erfolg IM_STATUS_SUCCESS zurück, andernfalls einen negativen Fehlercode.

3.25 Threadkontext-Konfiguration

3.25.1 imconfig

IM_STATUS  imconfig(IM_CONFIG_NAME name, uint64_t value);

Den Kontext des aktuellen Threads über verschiedene Konfigurationsnamen einstellen. Er liefert die Thread-Standardwerte und hat niedrigere Priorität als Schnittstellenargumente. Ohne explizite Parameterkonfiguration gelten die Kontextwerte; andernfalls hat für diesen Aufruf das übergebene Argument Vorrang.

priority und core sind Einstellungen mit sehr weitreichenden Rechten. Fehlbedienung kann Systemabstürze oder Deadlocks verursachen. Nur zur Entwicklung und Fehlersuche verwenden; von einer Konfiguration im Produktbetrieb wird dringend abgeraten. Bei Erfolg wird IM_STATUS_SUCCESS zurückgegeben, sonst ein negativer Fehlercode.

4. Datenstrukturen

Dieses Kapitel beschreibt die Datenstrukturen der Anwendungsschnittstellen im Detail.

4.1 Übersicht

4.2 Detailbeschreibungen

4.2.1 rga_buffer_t

Bildpufferinformationen eines Kanals.

Pfad: im2d_api/im2d_type.h. Definition:

typedef struct {
    void* vir_addr;                     /* virtual address */
    void* phy_addr;                     /* physical address */
    int fd;                             /* shared fd */
    rga_buffer_handle_t handle;         /* buffer handle */

    int width;                          /* width */
    int height;                         /* height */
    int wstride;                        /* wstride */
    int hstride;                        /* hstride */
    int format;                         /* format */

    int color_space_mode;               /* color_space_mode */
    int global_alpha;                   /* global_alpha */
    int rd_mode;
} rga_buffer_t;

Hinweise: Zur Bildpufferbeschreibung nur eines von vir_addr, phy_addr, fd oder handle wählen. Bei mehreren Zuweisungen wird genau eines nach Standardpriorität verwendet: handle > phy_addr > fd > vir_addr.

4.2.2 im_rect

Tatsächlicher Operationsbereich eines Kanals.

Pfad: im2d_api/im2d_type.h. Definition:

typedef struct {
    int x;        /* upper-left x */
    int y;        /* upper-left y */
    int width;    /* width */
    int height;   /* height */
} im_rect;

Der Operationsbereich darf die Bildgröße nicht überschreiten: (x + width) <= wstride und (y + height) <= hstride.

4.2.3 im_opt_t

Bildoperationsoptionen des aktuellen Tasks.

Pfad: im2d_api/im2d_type.h. Definition:

typedef struct im_opt {
    im_api_version_t version DEFAULT_INITIALIZER(RGA_CURRENT_API_HEADER_VERSION);
    int color;                          /* color, used by color fill */
    im_colorkey_range colorkey_range;   /* range value of color key */
    im_nn_t nn;
    int rop_code;
    int priority;
    int core;
    int mosaic_mode;
    im_osd_t osd_config;
    im_intr_config_t intr_config;
    char reserve[128];
} im_opt_t;

priority und core sind Einstellungen mit sehr weitreichenden Rechten. Fehlbedienung kann Systemabstürze oder Deadlocks verursachen. Nur zur Entwicklung und Fehlersuche verwenden; von einer Konfiguration im Produktbetrieb wird dringend abgeraten.

4.2.4 im_job_handle_t

RGA-Jobhandle zur Identifikation des aktuell konfigurierten Jobs.

Pfad: im2d_api/im2d_type.h. Definition:

typedef uint32_t im_job_handle_t;

Schlägt die Konfiguration fehl, das aktuelle Jobhandle mit imcancelJob freigeben, um Speicherlecks zu vermeiden.

4.2.5 rga_buffer_handle_t

Bildpufferhandle des RGA-Treibers.

Pfad: im2d_api/im2d_type.h. Definition:

typedef int rga_buffer_handle_t;

Nach der Speichernutzung mit releasebuffer_handle freigeben, um Speicherlecks zu vermeiden.

4.2.6 im_handle_param_t

Beschreibungsparameter des zu importierenden Bildpuffers.

Pfad: im2d_api/im2d_type.h. Definition:

typedef struct im_handle_param {
    uint32_t width;
    uint32_t height;
    uint32_t format;
} im_handle_param_t;

Diese Struktur beschreibt die Größe des zugewiesenen Puffers. Ist die tatsächliche Zuweisung kleiner als konfiguriert, schlägt importbuffer_T fehl.

4.2.7 im_nn_t

Parameter der NN-Vorverarbeitung (Quantisierung).

Pfad: im2d_api/im2d_type.h. Definition:

typedef struct im_nn {
    int scale_r;                /* scaling factor on R channal */
    int scale_g;                /* scaling factor on G channal */
    int scale_b;                /* scaling factor on B channal */
    int offset_r;               /* offset on R channal */
    int offset_g;               /* offset on G channal */
    int offset_b;               /* offset on B channal */
} im_nn_t;

Hinweise: keine.

4.2.8 im_colorkey_range

Farbschlüsselbereich.

Pfad: im2d_api/im2d_type.h. Definition:

typedef struct {
    int max;                    /* The Maximum value of the color key */
    int min;                    /* The minimum value of the color key */
} im_colorkey_range;

Hinweise: keine.

4.2.9 im_osd_block_t

OSD-Textblock-Beschreibungskonfiguration.

Pfad: im2d_api/im2d_type.h. Definition:

typedef struct im_osd_block {
    int width_mode;                 // normal or different
                                    //   IM_OSD_BLOCK_MODE_NORMAL
                                    //   IM_OSD_BLOCK_MODE_DIFFERENT
    union {
        int width;                  // normal_mode block width
        int width_index;            // different_mode block width index in RAM
    };

    int block_count;                // block count

    int background_config;          // background config is bright or dark
                                    //   IM_OSD_BACKGROUND_DEFAULT_BRIGHT
                                    //   IM_OSD_BACKGROUND_DEFAULT_DARK

    int direction;                  // osd block direction
                                    //   IM_OSD_MODE_HORIZONTAL
                                    //   IM_OSD_MODE_VERTICAL

    int color_mode;                 // using src1 color or config color
                                    //   IM_OSD_COLOR_PIXEL
                                    //   IM_OSD_COLOR_EXTERNAL
    im_color_t normal_color;        // config color: normal
    im_color_t invert_color;        // config color: invert
} im_osd_block_t;

Hinweise: keine.

4.2.10 im_osd_invert_factor_t

Konfiguration der OSD-Farbinvertierungsformel.

Pfad: im2d_api/im2d_type.h. Definition:

typedef struct im_osd_invert_factor {
    uint8_t alpha_max;
    uint8_t alpha_min;
    uint8_t yg_max;
    uint8_t yg_min;
    uint8_t crb_max;
    uint8_t crb_min;
} im_osd_invert_factor_t;

Formel: MAX(channel_min_factor, channel_max_factor - channel_value). Hinweise: keine.

4.2.11 im_osd_invert_t

OSD-Farbinvertierungskonfiguration.

Pfad: im2d_api/im2d_type.h. Definition:

typedef struct im_osd_invert {
    int invert_channel;         // invert channel config:
                                //   IM_OSD_INVERT_CHANNEL_NONE
                                //   IM_OSD_INVERT_CHANNEL_Y_G
                                //   IM_OSD_INVERT_CHANNEL_C_RB
                                //   IM_OSD_INVERT_CHANNEL_ALPHA
                                //   IM_OSD_INVERT_CHANNEL_COLOR
                                //   IM_OSD_INVERT_CHANNEL_BOTH
    int flags_mode;             // use external or inertnal RAM invert flags
                                //   IM_OSD_FLAGS_EXTERNAL
                                //   IM_OSD_FLAGS_INTERNAL
    int flags_index;            // flags index when using internal RAM invert flags

    uint64_t invert_flags;      // external invert flags
    uint64_t current_flags;     // current flags

    int invert_mode;            // invert use swap or factor
                                //   IM_OSD_INVERT_USE_FACTOR
                                //   IM_OSD_INVERT_USE_SWAP
    im_osd_invert_factor_t factor;

    int threash;
} im_osd_invert_t;

Hinweise: keine.

4.2.12 im_osd_bpp2_t

Konfiguration der OSD-BPP2-zu-RGB-Formatabbildung.

Pfad: im2d_api/im2d_type.h. Definition:

typedef struct im_osd_bpp2 {
    uint8_t  ac_swap;       // ac swap flag
                            // 0: CA
                            // 1: AC
    uint8_t  endian_swap;   // rgba2bpp endian swap
                            // 0: Big endian
                            // 1: Little endian
    im_color_t color0;
    im_color_t color1;
} im_osd_bpp2_t;

Hinweise: keine.

4.2.13 im_osd_t

OSD-Funktionskonfiguration.

Pfad: im2d_api/im2d_type.h. Definition:

typedef struct im_osd {

  int osd_mode;                 // osd mode: statistics or auto_invert
  im_osd_block_t block_parm;    // osd block info config
  im_osd_invert_t invert_config;
  im_osd_bpp2_t bpp2_info;
} im_osd_t;

Hinweise: keine.

5. Testfälle und Fehlersuche

Das Ausführen des Demos und die Analyse seines Quellcodes erleichtern das schnelle Verständnis und die Nutzung der oben beschriebenen Schnittstellen.

5.1 Testdateien

Die binären Ein-/Ausgabedateien vorab vorbereiten. Die RGBA8888-Quellbilder unter /sample/sample_file können direkt verwendet werden. Auf Android-Geräten die Quellen unter /data/, auf Linux-Geräten unter /usr/data ablegen. Dateinamensregeln:

in%dw%d-h%d-%s.bin
out%dw%d-h%d-%s.bin

⽰例：
1280×720 RGBA8888的输⼊图像： in0w1280-h720-rgba8888.bin
1280×720 RGBA8888的输出图像： out0w1280-h720-rgba8888.bin

Parameterbedeutung: Eingabedateien verwenden in, Ausgabedateien out. Das erste %d ist der Dateiindex, normalerweise 0, zur Unterscheidung gleicher Formate und Abmessungen. Das zweite %d ist die Breite, normalerweise die virtuelle Breite, das dritte die Höhe, normalerweise die virtuelle Höhe. Das vierte %s ist der Formatname. Häufige vordefinierte Testformate folgen; weitere Formatstrings stehen in rgaUtils.cpp.

Die Standardeingabe ist 1280x720 RGBA8888. in0w1280-h720-rgba8888.bin unter /data oder /usr/data vorbereiten. Für Komposition wird dort zusätzlich in1w1280-h720-rgba8888.bin benötigt.

5.2 Fehlersuche

Das Demo gibt folgende Logs aus (Bildkopiebeispiel). Android-Log:

# rgaImDemo --copy

librga:RGA_GET_VERSION:3.02,3.020000                    //RGA版本
ctx=0x7ba35c1520,ctx->rgaFd=3                           //RGA上下⽂
Start selecting mode
im2d copy ..                                            //RGA运⾏模式
GraphicBuffer check ok
GraphicBuffer check ok
lock buffer ok
open file ok                                            //src⽂件的状态，如果/data/⽬录下没有对应⽂件这⾥会报错
unlock buffer ok
lock buffer ok
unlock buffer ok
copying .... successfully                               //标志运⾏成功
open /data/out0w1280-h720-rgba8888.bin and write ok     //输出⽂件名以及⽬录

Linux-Log:

# rgaImDemo --copy

librga:RGA_GET_VERSION:3.02,3.020000                    //RGA版本
ctx=0x2b070,ctx->rgaFd=3                                //RGA上下⽂
Rga built version:version:1.00
Start selecting mode
im2d copy ..                                            //RGA运⾏模式
open file                                               //src⽂件的状态，如果/usr/data/⽬录下没有对应⽂件这⾥会报错
copying .... Run successfully                           //标志运⾏成功
open /usr/data/out0w1280-h720-rgba8888.bin and write ok //输出⽂件名以及⽬录

Für ausführlichere RGA-Logs unter Android die Konfigurationsausgabe über vendor.rga.log aktivieren (sys.rga.log unter Android 8 und älter):

setprop vendor.rga.log 1        打开RGA log打印
logcat -s librga                开启并过滤log打印
setprop vendor.rga.log 0        关闭RGA log打印

Unter Linux __DEBUG in core/NormalRgaContext.h auf 1 setzen und neu kompilieren.

#ifdef LINUX

-#define __DEBUG 0
+#define __DEBUG 1

Typische Logs folgen. Sie können zur Analyse durch zuständige RK-Ingenieure in RedMine hochgeladen werden. Android-Log:

D librga  : <<<<-------- print rgaLog -------->>>>
D librga  : src->hnd = 0x0 , dst->hnd = 0x0
D librga  : srcFd = 11 , phyAddr = 0x0 , virAddr = 0x0
D librga  : dstFd = 15 , phyAddr = 0x0 , virAddr = 0x0
D librga  : srcBuf = 0x0 , dstBuf = 0x0
D librga  : blend = 0 , perpixelAlpha = 1
D librga  : scaleMode = 0 , stretch = 0;
D librga  : rgaVersion = 3.020000  , ditherEn =0
D librga  : srcMmuFlag = 1 , dstMmuFlag = 1 , rotateMode = 0
D librga  : <<<<-------- rgaReg -------->>>>
D librga  : render_mode=0 rotate_mode=0
D librga  : src:[b,0,e1000],x-y[0,0],w-h[1280,720],vw-vh[1280,720],f=0
D librga  : dst:[f,0,e1000],x-y[0,0],w-h[1280,720],vw-vh[1280,720],f=0
D librga  : pat:[0,0,0],x-y[0,0],w-h[0,0],vw-vh[0,0],f=0
D librga  : ROP:[0,0,0],LUT[0]
D librga  : color:[0,0,0,0,0]
D librga  : MMU:[1,0,80000521]
D librga  : mode[0,0,0,0]

Linux-Log:

render_mode=0 rotate_mode=0
src:[0,a681a008,a68fb008],x-y[0,0],w-h[1280,720],vw-vh[1280,720],f=0
dst:[0,a6495008,a6576008],x-y[0,0],w-h[1280,720],vw-vh[1280,720],f=0
pat:[0,0,0],x-y[0,0],w-h[0,0],vw-vh[0,0],f=0
ROP:[0,0,0],LUT[0]
color:[0,0,0,0,0]
MMU:[1,0,80000521]
mode[0,0,0,0,0]
gr_color_x [0, 0, 0]
gr_color_x [0, 0, 0]

5.3 Testfälle

Die Tests liegen unter sample/im2d_api_demo im librga-Quellbaum. Die Demo-Konfiguration kann angepasst werden; beim ersten Lauf die Standardwerte verwenden. Die Kompilierung ist plattformabhängig: Android unterstützt mm; unter Linux entsteht beim CMake-Build von librga.so im selben Verzeichnis die Testdatei. Das kompilierte Programm per adb übertragen, Ausführungsrechte setzen, ausführen und die Logs prüfen. Kontrollieren, ob die Ausgabedatei den Erwartungen entspricht.

5.3.1 Bildpuffer zuweisen

Das Demo stellt Graphicbuffer und AHardwareBuffer für die RGA-Komposition bereit; die Auswahl erfolgt über USE_AHARDWAREBUFFER.

⽬录：librga/samples/im2d_api_demo/Android.mk
（line +15）

ifeq (1,$(strip $(shell expr $(PLATFORM_SDK_VERSION) \> 25)))
/*USE_AHARDWAREBUFFER为1则使⽤AHardwareBuffer，为0使⽤Graphicbuffer*/
LOCAL_CFLAGS += -DUSE_AHARDWAREBUFFER=1
endif

5.3.1.1 Graphicbuffer

Drei Funktionen initialisieren hauptsächlich Graphicbuffer, füllen/leeren den Puffer und befüllen rga_buffer_t.

/*传⼊src/dst的宽、⾼、图像格式，初始化Graphicbuffer*/
src_buf = GraphicBuffer_Init(SRC_WIDTH, SRC_HEIGHT, SRC_FORMAT);
dst_buf = GraphicBuffer_Init(DST_WIDTH, DST_HEIGHT, DST_FORMAT);

/*通过枚举值FILL_BUFF/EMPTY_BUFF，执⾏填充/清空Graphicbuffer*/
GraphicBuffer_Fill(src_buf, FILL_BUFF, 0);
if(MODE == MODE_BLEND)
    GraphicBuffer_Fill(dst_buf, FILL_BUFF, 1);
else
    GraphicBuffer_Fill(dst_buf, EMPTY_BUFF, 1);

/*填充rga_buffer_t结构体:src、dst*/
src = wrapbuffer_GraphicBuffer(src_buf);
dst = wrapbuffer_GraphicBuffer(dst_buf);

5.3.1.2 AHardwareBuffer

Drei Funktionen initialisieren hauptsächlich AHardwareBuffer, füllen/leeren den Puffer und befüllen rga_buffer_t.

/*传⼊src/dst的宽、⾼、图像格式，初始化AHardwareBuffer*/
AHardwareBuffer_Init(SRC_WIDTH, SRC_HEIGHT, SRC_FORMAT, &src_buf);
AHardwareBuffer_Init(DST_WIDTH, DST_HEIGHT, DST_FORMAT, &dst_buf);

/*通过枚举值FILL_BUFF/EMPTY_BUFF，执⾏填充/清空AHardwareBuffer*/
AHardwareBuffer_Fill(&src_buf, FILL_BUFF, 0);
if(MODE == MODE_BLEND)
    AHardwareBuffer_Fill(&dst_buf, FILL_BUFF, 1);
else
    AHardwareBuffer_Fill(&dst_buf, EMPTY_BUFF, 1);

/*填充rga_buffer_t结构体:src、dst*/
src = wrapbuffer_AHardwareBuffer(src_buf);
dst = wrapbuffer_AHardwareBuffer(dst_buf);

5.3.2 Hilfe anzeigen

Mit folgendem Befehl die Testhilfe abrufen.

rgaImDemo -h
rgaImDemo --help
rgaImDemo

Nach erfolgreicher Ausführung das Demo entsprechend der angezeigten Hilfe verwenden:

rk3399_Android10:/ # rgaImDemo
librga:RGA_GET_VERSION:3.02,3.020000
ctx=0x7864d7c520,ctx->rgaFd=3

=============================================================================================
   usage: rgaImDemo [--help/-h] [--while/-w=(time)] [--querystring/--querystring=<options>]
                    [--copy] [--resize=<up/down>] [--crop] [--rotate=90/180/270]
                    [--flip=H/V] [--translate] [--blend] [--cvtcolor]
                    [--fill=blue/green/red]
         --help/-h     Call help
         --while/w     Set the loop mode. Users can set the number of cycles by themselves.
         --querystring You can print the version or support information corresponding to the current version
of RGA according to the options.
                       If there is no input options, all versions and support information of the current
version of RGA will be printed.
                       <options>:
                       vendor           Print vendor information.
                       version          Print RGA version, and librga/im2d_api version.
                       maxinput         Print max input resolution.
                       maxoutput        Print max output resolution.
                       scalelimit       Print scale limit.
                       inputformat      Print supported input formats.
                       outputformat     Print supported output formats.
                       expected         Print expected performance.
                       all              Print all information.
         --copy        Copy the image by RGA.The default is 720p to 720p.
         --resize      resize the image by RGA.You can choose to up(720p->1080p) or down(720p->480p).
         --crop        Crop the image by RGA.By default, a picture of 300*300 size is cropped from (100,100).
         --rotate      Rotate the image by RGA.You can choose to rotate 90/180/270 degrees.

         --flip        Flip the image by RGA.You can choice of horizontal flip or vertical flip.
         --translate   Translate the image by RGA.Default translation (300,300).
         --blend       Blend the image by RGA.Default, Porter-Duff 'SRC over DST'.
         --cvtcolor    Modify the image format and color space by RGA.The default is RGBA8888 to NV12.
         --fill        Fill the image by RGA to blue, green, red, when you set the option to the corresponding
color.
=============================================================================================

Die gesamte Argumentverarbeitung befindet sich in /librga/demo/im2d_api_demo/args.cpp.

5.3.3 Demo wiederholt ausführen

Mit folgendem Befehl das Demo wiederholt ausführen. Die Schleifenanweisung muss vor allen Argumenten stehen. Die Wiederholungszahl ist int; das Standardintervall beträgt 200ms.

rgaImDemo -w6 --copy
rgaImDemo --while=6 --copy

5.3.4 RGA-Version und Unterstützung abfragen

Mit folgendem Befehl Versions- und Unterstützungsinformationen abrufen:

rgaImDemo --querystring
rgaImDemo --querystring=<options>

Dieser Befehl akzeptiert Optionen; ohne Optionen gilt =all. Verfügbare Optionen:

options：
    =vendor             打印⼚商信息
    =version            打印版本信息
    =maxinput           打印⽀持的最⼤输⼊分辨率
    =maxoutput          打印⽀持的最⼤输出分辨率
    =scalelimit         打印⽀持的缩放倍数
    =inputformat        打印⽀持的输⼊格式
    =outputformat       打印⽀持的输出格式
    =expected           打印预期性能
    =all                打印所有信息

5.3.4.1 Codeanalyse

Die Argumente von main() bestimmen die ausgegebenen Informationen.

/*将main()传参转化为QUERYSTRING_INFO枚举值*/
IM_INFO = (QUERYSTRING_INFO)parm_data[MODE_QUERYSTRING];
/*打印querystring()返回的字符串，即所需要的信息*/
printf("\n%s\n", querystring(IM_INFO));

5.3.5 Bildskalierung

Mit folgendem Befehl Bildskalierung testen.

rgaImDemo --resize=up
rgaImDemo --resize=down

Diese Funktion benötigt eine Option. Verfügbare Optionen:

options：
    =up                 图像分辨率放⼤⾄1920x1080
    =down               图像分辨率缩⼩⾄720x480

5.3.5.1 Codeanalyse

Das Argument up/down von main() wählt Vergrößerung oder Verkleinerung. Den Puffer dafür neu initialisieren und leeren, rga_buffer_t befüllen und die endgültigen src-/dst-Bildbeschreibungen an imresize() übergeben.

switch(parm_data[MODE_RESIZE])
{
    /*放⼤图像*/
    case IM_UP_SCALE :
        /*重新初始化Graphicbuffer为分辨率1920x1080对应⼤⼩*/
        dst_buf = GraphicBuffer_Init(1920, 1080, DST_FORMAT);
        /*清空buffer*/
        GraphicBuffer_Fill(dst_buf, EMPTY_BUFF, 1);
        /*重新填充存储dst数据的rga_buffer_t结构体*/
        dst = wrapbuffer_GraphicBuffer(dst_buf);
        break;

    case IM_DOWN_SCALE :
        /*重新初始化Graphicbuffer为分辨率1920x1080对应⼤⼩*/
        dst_buf = GraphicBuffer_Init(720, 480, DST_FORMAT);
        /*清空buffer*/
        GraphicBuffer_Fill(dst_buf, EMPTY_BUFF, 1);
        /*重新填充存储dst数据的rga_buffer_t结构体*/
        dst = wrapbuffer_GraphicBuffer(dst_buf);
        break;
}
/*将rga_buffer_t格式的结构体src、dst传⼊imresize()*/
STATUS = imresize(src, dst);
/*根据返回的IM_STATUS枚举值打印运⾏状态*/
printf("resizing .... %s\n", imStrError(STATUS));

5.3.6 Bildzuschnitt

Mit folgendem Befehl Bildzuschnitt testen.

rgaImDemo --crop

Keine Optionen verfügbar. Standardmäßig wird der Bereich LT(100,100), RT(400,100), LB(100,400), RB(400,400) zugeschnitten.

5.3.6.1 Codeanalyse

Die Zuschnittmaße im im_rect für das src-Rechteck setzen und die rga_buffer_t-Strukturen für src und dst an imcrop() übergeben.

/*这⾥通过x、y确定裁剪顶点的坐标，width、height确定裁剪区域⼤⼩*/
src_rect.x      = 100;
src_rect.y      = 100;
src_rect.width  = 300;
src_rect.height = 300;

/*将im_rect格式的结构体src_rect与rga_buffer_t格式的结构体src、dst传⼊imcrop()*/
STATUS = imcrop(src, dst, src_rect);
/*根据返回的IM_STATUS枚举值打印运⾏状态*/
printf("cropping .... %s\n", imStrError(STATUS));

5.3.7 Bildrotation

Mit folgendem Befehl Bildrotation testen.

rgaImDemo --rotate=90
rgaImDemo --rotate=180
rgaImDemo --rotate=270

Diese Funktion benötigt eine Option. Verfügbare Optionen:

options：
    =90                 图像旋转90° ，输出图像分辨率宽⾼交换
    =180                图像旋转180°，输出图像分辨率不变
    =270                图像旋转270°，输出图像分辨率宽⾼交换

5.3.7.1 Codeanalyse

Das main()-Argument 90/180/270 wählt den Drehwinkel. In einen IM_USAGE-Enumerationswert umwandeln und zusammen mit den rga_buffer_t-Strukturen für src und dst an imrotate() übergeben.

/*将main()传参转化为IM_USAGE枚举值*/
ROTATE = (IM_USAGE)parm_data[MODE_ROTATE];

/*将标识旋转⻆度的IM_USAGE枚举值与rga_buffer_t格式的结构体src、dst⼀同传⼊imrotate()*/
STATUS = imrotate(src, dst, ROTATE);
/*根据返回的IM_STATUS枚举值打印运⾏状态*/
printf("rotating .... %s\n", imStrError(STATUS));

5.3.8 Bildspiegelung

Mit folgendem Befehl Bildspiegelung testen.

rgaImDemo --flip=H
rgaImDemo --flip=V

Diese Funktion benötigt eine Option. Verfügbare Optionen:

options：
    =H                  图像⽔平镜像翻转
    =V                  图像垂直镜像翻转

5.3.8.1 Codeanalyse

Das main()-Argument H/V wählt die Spiegelrichtung. In einen IM_USAGE-Wert umwandeln und zusammen mit den rga_buffer_t-Strukturen für src und dst an imflip() übergeben.

/*将main()传参转化为IM_USAGE枚举值*/
FLIP = (IM_USAGE)parm_data[MODE_FLIP];

/*将标识镜像反转⽅向的IM_USAGE枚举值与rga_buffer_t格式的结构体src、dst⼀同传⼊imflip()*/
STATUS = imflip(src, dst, FLIP);
/*根据返回的IM_STATUS枚举值打印运⾏状态*/
printf("flipping .... %s\n", imStrError(STATUS));

5.3.9 Farbfüllung

Mit folgendem Befehl Farbfüllung testen.

rgaImDemo --fill=blue
rgaImDemo --fill=green
rgaImDemo --fill=red

Eine Option ist erforderlich. Der Standardfüllbereich ist LT(100,100), RT(400,100), LB(100,400), RB(400,400). Verfügbare Optionen:

options：
    =blue               图像颜⾊填充为蓝⾊
    =green              图像颜⾊填充为绿⾊
    =red                图像颜⾊填充为红⾊

5.3.9.1 Codeanalyse

Das main()-Argument (bule/green/red, Schreibweise der Quelle) wählt die Füllfarbe. Die Füllmaße im im_rect für dst setzen, das Argument in einen hexadezimalen Farbwert umwandeln und zusammen mit der dst-Struktur rga_buffer_t an imfill() übergeben.

/*将main()传参转化为对应颜⾊的16进制数*/
COLOR = parm_data[MODE_FILL];

/*这⾥通过x、y确定裁剪顶点的坐标，width、height确定填充颜⾊区域⼤⼩*/
dst_rect.x      = 100;
dst_rect.y      = 100;
dst_rect.width  = 300;
dst_rect.height = 300;

/*将im_rect格式的结构体dst_rect、对应颜⾊的16进制数与rga_buffer_t格式的结构体src、dst⼀同传⼊imfill()*/
STATUS = imfill(dst, dst_rect, COLOR);
/*根据返回的IM_STATUS枚举值打印运⾏状态*/
printf("filling .... %s\n", imStrError(STATUS));

5.3.10 Bildverschiebung

Mit folgendem Befehl Bildverschiebung testen.

rgaImDemo --translate

Keine Optionen verfügbar. Der linke obere Eckpunkt wird standardmäßig nach (300,300) verschoben: 300 Pixel nach rechts und 300 nach unten.

5.3.10.1 Codeanalyse

Die Verschiebungswerte im im_rect für das src-Rechteck setzen und die rga_buffer_t-Strukturen für src und dst an imtranslate() übergeben.

/*这⾥通过x、y确定平移后图像的顶点的坐标*/
src_rect.x = 300;
src_rect.y = 300;

/*将im_rect格式的结构体src_rect与rga_buffer_t格式的结构体src、dst⼀同传⼊imtranslate()*/
STATUS = imtranslate(src, dst, src_rect.x, src_rect.y);
/*根据返回的IM_STATUS枚举值打印运⾏状态*/
printf("translating .... %s\n", imStrError(STATUS));

5.3.11 Bildkopie

Mit folgendem Befehl Bildkopie testen.

rgaImDemo --copy

Keine Optionen verfügbar. Standardmäßig wird ein 1280x720-RGBA8888-Bild kopiert.

5.3.11.1 Codeanalyse

Die rga_buffer_t-Strukturen mit den Bilddaten von src und dst an imcopy() übergeben.

/*rga_buffer_t格式的结构体src、dst传⼊imcopy()*/
STATUS = imcopy(src, dst);
/*根据返回的IM_STATUS枚举值打印运⾏状态*/
printf("copying .... %s\n", imStrError(STATUS));

5.3.12 Bildkomposition

Mit folgendem Befehl Bildkomposition testen.

rgaImDemo --blend

Keine Optionen verfügbar. Die Quelle nennt IM_ALPHA_BLEND_DST als Standardkompositionsmodus.

5.3.12.1 Codeanalyse

Die rga_buffer_t-Strukturen mit den Bilddaten von src und dst an imblend() übergeben.

/*rga_buffer_t格式的结构体src、dst传⼊imblend()*/
STATUS = imblend(src, dst);
/*根据返回的IM_STATUS枚举值打印运⾏状态*/
printf("blending .... %s\n", imStrError(STATUS));

5.3.13 Bildformatkonvertierung

Mit folgendem Befehl Bildformatkonvertierung testen.

rgaImDemo --cvtcolor

Keine Optionen verfügbar. Standardmäßig wird ein 1280x720-Bild von RGBA8888 nach NV12 konvertiert.

5.3.13.1 Codeanalyse

Die benötigten Formate in den format-Feldern von rga_buffer_t setzen und die src-/dst-Bildstrukturen an imcvtcolor() übergeben.

/*将转换前后的格式赋值给对应的rga_buffer_t结构体的成员变量format*/
src.format = HAL_PIXEL_FORMAT_RGBA_8888;
dst.format = HAL_PIXEL_FORMAT_YCrCb_NV12;

/*将需要转换的格式与rga_buffer_t格式的结构体src、dst⼀同传⼊imcvtcolor()*/
STATUS = imcvtcolor(src, dst, src.format, dst.format);
/*根据返回的IM_STATUS枚举值打印运⾏状态*/
printf("cvtcolor .... %s\n", imStrError(STATUS));

Quellenvergleich: ebenfalls als V2.2.7 bezeichnetes englisches Original

Die folgenden abweichenden Definitionen der englischen Quelle dienen der Nachvollziehbarkeit, nicht dem Vermischen mit vorherigem Code. Mit tatsächlichen SDK-Headern, librga und Treiberversionen abgleichen. Die englische Quelle enthält weder die fünf OSD-Strukturen der chinesischen §§4.2.9–4.2.13 noch die erweiterten im_opt_t-Felder; diese sind oben vollständig ergänzt.

§3.20.1 imfill: Englisch verwendet buf, Standardfarbe 0x00000000 und kein release_fence_fd; Chinesisch dst, obligatorisches color und zusätzliches release_fence_fd.

IM_STATUS imfill(rga_buffer_t buf,
                 im_rect rect,
                 int color = 0x00000000,
                 int sync = 1);

§4.2.3 im_opt_t: die kürzere englische Struktur enthält die chinesischen Felder version, mosaic_mode, osd_config, intr_config und reserve nicht.

typedef struct im_opt {
    int color;                          /* color, used by color fill */
    im_colorkey_range colorkey_range;   /* range value of color key */
    im_nn_t nn;
    int rop_code;

    int priority;
    int core;
} im_opt_t;

§4.2.6 im_handle_param_t: Englisch verwendet rga_memory_parm mit width_stride/height_stride, Chinesisch im_handle_param mit width/height. Die englische Parametertabelle verwendet ebenfalls width_stride/height_stride. Keine ABI-Gleichheit unterstellen.

typedef struct rga_memory_parm im_handle_param_t;

struct rga_memory_parm {
    uint32_t width_stride;
    uint32_t height_stride;
    uint32_t format;
};

§3.8.1 imcopy: das englische Original enthält eine zusätzliche schließende Klammer nach sync = 1. Unten bleibt dies als Quellproblem erhalten; oben steht die chinesische Signatur.

IM_STATUS imcopy(const rga_buffer_t src,
                 rga_buffer_t dst,
                 int sync = 1),
                 int *release_fence_fd = NULL);

§3.15.1 imblend: Englisches srcA/dst entspricht chinesischem fg_image/bg_image; die Parameternamen unterscheiden sich.

IM_STATUS imblend(const rga_buffer_t srcA,
                  rga_buffer_t dst,
                  int mode = IM_ALPHA_BLEND_SRC_OVER,
                  int sync = 1,
                  int *release_fence_fd = NULL);

§3.15.1 imcomposite: Englisches srcA/srcB/dst entspricht chinesischem fg_image/bg_image/output_image.

IM_STATUS imcomposite(const rga_buffer_t srcA,
                      const rga_buffer_t srcB,
                      rga_buffer_t dst,
                      int mode = IM_ALPHA_BLEND_SRC_OVER,
                      int sync = 1,
                      int *release_fence_fd = NULL);