Rockchip ISP30-Entwicklung: vollständiger Leitfaden zu RK3588, RkAiq-API und Debugging

Diese Plattformreferenz bewahrt den vollständigen technischen Haupttext der 436-seitigen englischen Quelle V1.2.5 (PDF S. 16–436), einschließlich RK-RAW-Formaten und abschließender Kapitel zu Fehlercodes und Abkürzungen. Ein entsprechendes chinesisches PDF wurde nicht bereitgestellt. Die chinesische, russische und deutsche Fassung sind vollständige Übersetzungen dieser englischen Version; alle 42 technischen Originalabbildungen stammen aus dem englischen PDF, einschließlich dort bereits vorhandener chinesischer Beschriftungen. Zehn bildbasierte RAW-Aufbau-/Formattabellen sind zusätzlich als editierbare Tabellen transkribiert. Keine Ganzseitenbilder ersetzen den Haupttext.

Die Quelle nennt RK3588 / Linux 5.10; BuildRoot und Android sind mit Y, Debian und Yocto mit N gekennzeichnet. Dies sind historische Quellenangaben, keine Unterstützungszusage für jedes BSP. Prüfen Sie für ArmSoM-Platinen zuerst den genauen SoC, die ISP-Generation, Sensor/VCM, Kernel, AIQ-Bibliothek, IQ-Datei und SDK/BSP-Zweig. ArmSoM Sige7 ist eine RK3588-Platine, die APIs und Beispiele dieses Artikels wurden jedoch nicht auf ihrer Hardware validiert. Alle Messungen und Beispiele stammen aus der Quelle; keine Hardwarebefehle oder Kamera-/Motoroperationen wurden ausgeführt.

Unklarheiten der Quelle: Wiederholte API-Überschriften, vermischte ISP-Generationen und Typen sowie widersprüchliche Einheiten, Standardwerte, Protokollstufen und RAW-Feldbeschreibungen bleiben erhalten und sind in den redaktionellen Anmerkungen aufgeführt. Werte und Bezeichner werden nicht stillschweigend korrigiert. Codekommentare bleiben in ihrer Originalsprache. Befehle und APIs können den Kamera- oder Motorzustand verändern; passen und prüfen Sie sie vor Verwendung.

Redaktionelle Anmerkungen · ArmSoM Sige7 · ArmSoM-Kameradokumentation · Rockchip Linux

1. Gesamtüberblick

1.1 Strukturdiagramm

RK3588 VI umfasst als Sammelbegriff für Videoeingangsmodule:

Schnittstellen und Datenerfassung: C/DPHY, DVP, CSI, VICAP

Bildverarbeitung: ISP-0,ISP-1,FEC-0,FEC-1

Der RK3588 ISP gehört zur Version RK ISP v3.0 und wird in der weiteren Dokumentation als ISP30 bezeichnet.

1.2 Betriebsarten

Einzelner ISP, einzelner CIS (CMOS Image Sensor):

RAW-Durchleitungs-/Online-Modus: Die blauen Pfeile im Blockdiagramm zeigen den Datenflusspfad 1.0.

Raw-Rücklese-/Offline-Modus: Die orangefarbenen Pfeile im Blockdiagramm zeigen die Datenflusspfade 1.1 und 1.2.

Dual-ISP-2-in-1-Modus für einen einzelnen CIS:

Im 2-in-1-Modus verarbeiten ISP-0/ISP-1 den linken und rechten Teil eines einzelnen CIS-Bildes getrennt, um CIS mit hoher Auflösung zu unterstützen.

Mehrere CIS:

Ein einzelner ISP verwendet den Raw-Rücklese-/Offline-Modus und kann dadurch mehrere CIS-Eingänge im Zeitmultiplexbetrieb unterstützen.

1.3 Überblick über Leistung und Einschränkungen

Unterstützte Auflösungen und Durchsatz:

Unterstützung für Raw12-Dateneingang.

ISP30 unterstützt die Verarbeitung von Raw12-Daten. Bei Raw14-Eingang werden die niederwertigen Bits für die Raw12-Verarbeitung verworfen. Bei Bilddaten mit weniger als 12 Bit werden die niederwertigen Bits zur Raw12-Verarbeitung ergänzt.

Unterstützung für Bayer-Farb-CIS und Mono-CIS.

Unterstützung für 3-in-1-Mehrbild-HDR. Folgende HDR-CIS-Typen werden unterstützt:

Geringste Latenz bis zur Benachrichtigung über die ISP30-Datenausgabe nach DDR im Raw-Durchleitungs-/Online-Modus: ungefähr Übertragungszeit eines Bildes/15.

Im ISP-Zeitmultiplexmodus unterstützt ein einzelner ISP bis zu vier Datenquelleneingänge.

Im RAW-Durchleitungs-/Online-Modus beträgt die minimale Bildaustastung 136 Zeilen und die minimale Zeilenaustastung 16 Pixel.

Das CSM-Modul unterstützt keine Umwandlung auf den begrenzten YUV-Wertebereich; Einzelheiten siehe API-Beschreibung des IMGPROC/CSM-Moduls.

2. Überblick

ISP30 umfasst eine Reihe von Bildverarbeitungsalgorithmusmodulen, insbesondere Dunkelstromkorrektur, Defektpixelkorrektur, 3A, HDR, Objektivschattierungskorrektur, Objektivverzeichnungskorrektur, 3DLUT, Rauschunterdrückung (einschließlich RAW-Domäne, Mehrbild-Rauschunterdrückung und Farbrauschunterdrückung), Schärfung usw.

ISP30 umfasst eine Hardwareimplementierung der Algorithmen und einen Teil zur logischen Softwaresteuerung. RkAiq implementiert die logische Softwaresteuerung.

Die Hauptfunktionen des RkAiq-Softwaremoduls sind das Abrufen von Bildstatistiken vom ISP-Treiber, ihre Kombination mit IQ-Abstimmparametern und die Berechnung neuer ISP-, Sensor- und weiterer Hardwareparameter durch eine Reihe von Algorithmen. Dieser Vorgang wird kontinuierlich wiederholt, um schließlich die beste Bildwirkung zu erzielen.

2.1 Funktionsbeschreibung

Abbildung 1-1 ISP21-Systemblockdiagramm

Das gesamte Software-/Hardwareblockdiagramm von ISP30 ist in Abbildung 1-1 dargestellt. Der Sensor liefert einen Datenstrom an ISP HW, das nach einer Reihe von Bildverarbeitungsalgorithmen das Bild ausgibt. RkAiq ruft kontinuierlich statistische Daten von ISP HW ab und erzeugt mit Algorithmen wie 3A neue Parameter zur Rückkopplung an jedes Hardwaremodul. Das Abstimmwerkzeug kann Parameter online in Echtzeit abstimmen; anschließend lässt sich eine neue IQ-Parameterdatei speichern und erzeugen.

2.2 RkAiq-Architektur

Abbildung 1-2 Gesamtarchitektur von RkAiq

1. Das Softwarekonzept von ISP30 RkAiq ist in Abbildung 1-2 dargestellt. Es gliedert sich hauptsächlich in folgende vier Teile:

1. Dynamische Bibliothek RkAiq lib. Diese Bibliothek enthält die Hauptlogik, die Statistiken vom Treiber abruft und an die einzelnen Algorithmusbibliotheken weiterleitet.

2. Integrierte Algorithmusbibliotheken. Die von Rk bereitgestellte statische Algorithmusbibliothek wird standardmäßig bei der dynamischen Bibliothek RkAiq lib registriert.

3. Kundeneigene 3A-Bibliotheken. Kunden können entsprechend der Schnittstellendefinition eigene 3A- oder andere Algorithmusbibliotheken implementieren. Nach Registrierung einer eigenen Algorithmusbibliothek bei der dynamischen Bibliothek RkAiq lib lässt sich über die bereitgestellte Schnittstelle auswählen, ob die eigene oder die Rk-Bibliothek ausgeführt wird.

4. IQ-Datei. Ergebnisdateien der IQ-Abstimmung speichern algorithmusbezogene Parameter sowie einige statische Systemparameter, beispielsweise zum CIS.

2.3 Softwarearchitektur

Abbildung 1-3 Blockdiagramm der Softwarearchitektur

Das ISP30-Softwareblockdiagramm in Abbildung 1-3 gliedert sich hauptsächlich in folgende drei Schichten:

1. Kernelschicht. Sie enthält alle Hardwaretreiber des Kamerasystems, insbesondere ISP-, Sensor-, VCM-, Blitzlicht- und IrCutter-Treiber usw. Die Treiber basieren auf V4L2 und dem Media-Framework.

2. Framework-Schicht. Diese Schicht integriert RkAiq lib auf zwei mögliche Arten:

IspServer-Modus: Rkaiq lib läuft in einem eigenständigen IspServer-Prozess, mit dem der Client über dbus kommuniziert. Außerdem kann dieser Ansatz bestehenden Drittanwendungen wie v4L-CTL ohne Quellcodeänderung Bilder mit ISP-Abstimmwirkung bereitstellen.

Direkte Integration: RkAiq lib kann direkt in Anwendungen integriert werden.

3. Benutzerschicht. Anwendungsschicht des Benutzers.

2.4 Softwareabläufe

Abbildung 1-4 Ablaufdiagramm

Der Aufrufablauf der RkAiq-Schnittstellen ist in Abbildung 1-4 dargestellt. Gestrichelt umrahmte Teile sind optional; die blaue Schrift kennzeichnet die Konfiguration, die die Anwendung zusammen mit dem RkAiq-Ablauf verwenden muss.

configure media pipeline: Optional die ISP30-Pipeline konfigurieren, beispielsweise die Sensorausgangsauflösung; der Treiber besitzt eine Standardkonfiguration. rk_aiq_uapi2_sysctl_init: RkAiq einschließlich der IQ-Abstimmparameter und verschiedener Algorithmusbibliotheken initialisieren. other Aiq or algo params uapis: Optional erforderliche Parameter über die APIs der einzelnen Algorithmen konfigurieren und Drittanbieter-Algorithmusbibliotheken registrieren. rk_aiq_uapi2_sysctl_prepare: Die Initialisierungsparameter jeder Algorithmusbibliothek und jedes Hardwaremoduls vorbereiten und an den Treiber übergeben.

video capture start: Dieser Vorgang aktiviert den ISP-Datenfluss der Anwendung und muss nach rk_aiq_uapi2_sysctl_prepare aufgerufen werden.

rk_aiq_uapi2_sysctl_start: Den internen RkAiq-Ablauf starten. Nach erfolgreichem Schnittstellenaufruf beginnt der Sensor mit der Datenausgabe; der ISP verarbeitet die Daten und gibt das verarbeitete Bild aus.

Rkaiq running: RkAiq ruft kontinuierlich Statistiken vom ISP-Treiber ab, berechnet mit Algorithmen wie 3A neue Parameter und wendet sie auf den Treiber an. PC Online Tuning Tool: Der PC kann die Parameter online über das Abstimmwerkzeug anpassen. video capture stop: Vor dem Stoppen des RkAiq-Ablaufs muss der Datenfluss angehalten werden. rk_aiq_uapi2_sysctl_stop: Den laufenden RkAiq-Ablauf stoppen. Sie können Parameter anpassen und erneut starten oder direkt erneut starten.

rk_aiq_uapi2_sysctl_deinit: RkAiq deinitialisieren.

2.5 API-Beschreibung

Die von RKAiq bereitgestellten APIs sind in zwei Ebenen unterteilt: funktionsbezogene und modulbezogene APIs.

Funktionsbezogene API: Kapselt modulbezogene APIs und richtet sich hauptsächlich an Produktanwendungen mit einfachen, auf Modulfunktionen basierenden Aufgaben.

Modulbezogene API: Detaillierte Parametereinstellung und -abfrage für das jeweilige Modul ohne funktionale Unterteilung der API.

Die modulbezogenen APIs von RKAiq unterstützen synchrone und asynchrone Modi. Funktionsbezogene APIs kapseln standardmäßig den synchronen Modus der modulbezogenen APIs.

Synchroner Modus (Sync): Diese API arbeitet blockierend. AIQ aktualisiert Parameter grundsätzlich bildweise; im synchronen Modus kann der aufrufende Thread für eine Zeit <= der Videobildperiode blockiert werden.

Asynchroner Modus (ASync): Diese API arbeitet nicht blockierend. Das AIQ-Framework speichert API-Einstellparameter im internen Parameterpuffer und überträgt zum jeweiligen Zeitpunkt die neuesten ISP-Parameter an die Hardware.

Hinweise zur Verwendung synchroner und asynchroner Modi modulbezogener APIs

Die zweite Parameterstruktur einer modulbezogenen API enthält gewöhnlich die Einstellparameter und wird Eigenschaftsstruktur genannt. Ihre internen rk_aiq_uapi_sync_t-Elemente konfigurieren den Aufrufmodus der jeweiligen API; Einzelheiten enthalten folgende Datentypen:

2.5.1 rk_aiq_uapi_sync_t

【Beschreibung】 Synchronisationsmodus des Moduls

【Definition】

 typedef struct rk_aiq_uapi_sync_s {
     rk_aiq_uapi_mode_sync_e     sync_mode;
     bool                        done;
 } rk_aiq_uapi_sync_t;

【Felder】

Der AIQ-API-Referenzcode ist nach Modulen gegliedert und enthält separate API-Beispiele; Kunden wird empfohlen, diese direkt als Referenz zu verwenden.

rkisp_demo/demo/sample

3. Systemsteuerung

3.1 Funktionsüberblick

Die Systemsteuerung umfasst die Konfiguration allgemeiner AIQ-Eigenschaften, Initialisierung, Ausführung und Beendigung von AIQ, Einstellung von AIQ-Modulen und weitere Funktionen.

3.2 API-Referenz

3.2.1 rk_aiq_uapi2_sysctl_preInit

【Beschreibung】 Vor der AIQ-Initialisierung einige Parameter voreinstellen, beispielsweise die verwendete IQ-Datei.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_preInit (const char* sns_ent_name,
                          rk_aiq_working_mode_t mode,
                          const char* force_iq_file);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

【Hinweis】

Muss vor rk_aiq_uapi2_sysctl_init aufgerufen werden.

Der Parameter mode dient nur zur Auswahl von IQ-Dateien und konfiguriert nicht die ISP-Betriebsart. Diese muss in rk_aiq_uapi2_sysctl_prepare konfiguriert werden. Ist force_iq_file nicht leer, ist der Parameter mode unwirksam.

Der Parameter force_iq_file enthält den vollständigen Pfad.

Diese Funktion ist optional und dient nur zur Änderung einiger Standardeinstellungen vor rk_aiq_uapi2_sysctl_init.

3.2.2 rk_aiq_uapi2_sysctl_preInit_scene

【Beschreibung】 Vor der AIQ-Initialisierung die IQ-Szenarioparameter auswählen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_preInit_scene (const char* sns_ent_name,
                          const char *main_scene,
                         const char *sub_scene);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

【Hinweis】

Muss vor rk_aiq_uapi2_sysctl_init aufgerufen werden.

main_scene muss anhand des Hauptszenen-Arrays in der IQ-Datei ausgewählt werden; der Standardwert lautet gewöhnlich “normal”.

sub_scene muss anhand des Unterszenen-Arrays innerhalb der Hauptszene in der IQ-Datei ausgewählt werden; der Standardwert lautet gewöhnlich “day”.

Da standardmäßig normal-day gewählt wird, muss für hdr-day oder andere benutzerdefinierte Modi diese Funktion zur expliziten Auswahl aufgerufen werden. Andernfalls können die IQ-Parameter falsch sein.

3.2.3 rk_aiq_uapi2_sysctl_switch_scene

【Beschreibung】 Nach der AIQ-Initialisierung die IQ-Szenarioparameter umschalten.

【Syntax】

 int
 rk_aiq_uapi2_sysctl_switch_scene (const rk_aiq_sys_ctx_t* sys_ctx,
                          const char *main_scene,
                         const char *sub_scene);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

【Hinweis】

Nach rk_aiq_uapi2_sysctl_init aufrufen.

main_scene muss anhand des Hauptszenen-Arrays in der IQ-Datei ausgewählt werden.

sub_scene muss anhand des Unterszenen-Arrays innerhalb der Hauptszene in der IQ-Datei ausgewählt werden.

Diese Schnittstelle schaltet IQ dynamisch um. Dies ist derzeit unzureichend getestet und kann unerwartete Ergebnisse verursachen; daher vorsichtig verwenden.

3.2.4 rk_aiq_uapi2_sysctl_init

【Beschreibung】 AIQ-Kontext initialisieren.

【Syntax】

 rk_aiq_sys_ctx_t*
 rk_aiq_uapi2_sysctl_init (const char* sns_ent_name,
                          const char* iq_file_dir,
                          rk_aiq_error_cb err_cb,
                          rk_aiq_metas_cb metas_cb);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

【Hinweis】

Muss vor anderen Funktionsaufrufen erfolgen.

3.2.5 rk_aiq_uapi2_sysctl_deinit

【Beschreibung】 AIQ-Kontext deinitialisieren.

【Syntax】

 void
 rk_aiq_uapi2_sysctl_deinit( rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

【Hinweis】

Darf nicht aufgerufen werden, während sich AIQ im gestarteten Zustand befindet.

3.2.6 rk_aiq_uapi2_sysctl_prepare

【Beschreibung】 AIQ-Ausführungsumgebung vorbereiten.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_prepare(const rk_aiq_sys_ctx_t* ctx,
                            uint32_t  width,
                            uint32_t  height,
                            rk_aiq_working_mode_t mode);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

【Hinweis】

Muss vor rk_aiq_uapi2_sysctl_start aufgerufen werden.

Wenn diese Funktion nach rk_aiq_uapi2_sysctl_start benötigt wird, rufen Sie zuerst rk_aiq_uapi2_sysctl_stop und anschließend rk_aiq_uapi2_sysctl_prepare auf, um die Ausführungsumgebung erneut vorzubereiten.

3.2.7 rk_aiq_uapi2_sysctl_start

【Beschreibung】 AIQ-Steuerungssystem starten. Nach dem Start ruft AIQ kontinuierlich 3A-Statistiken vom ISP-Treiber ab, führt den 3A-Algorithmus aus und wendet die neu berechneten Parameter an.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_start(const rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

【Hinweis】

Muss nach rk_aiq_uapi2_sysctl_prepare aufgerufen werden.

3.2.8 rk_aiq_uapi2_sysctl_stop

【Beschreibung】 AIQ-Steuerungssystem stoppen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_stop(const rk_aiq_sys_ctx_t* ctx, bool keep_ext_hw_st);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

3.2.9 rk_aiq_uapi2_sysctl_getStaticMetas

【Beschreibung】 Die zum Sensor gehörenden statischen Informationen wie Auflösung, Datenformat usw. abfragen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_getStaticMetas(const char* sns_ent_name,
 rk_aiq_static_info_t* static_info);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

3.2.10 rk_aiq_uapi2_sysctl_enumStaticMetas

【Beschreibung】 Die von AIQ ermittelten statischen Informationen aufzählen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_enumStaticMetas(int index, rk_aiq_static_info_t*
 static_info);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

3.2.11 rk_aiq_uapi2_sysctl_enableAxlib

【Beschreibung】 Ausführungszustand der benutzerdefinierten Algorithmusbibliothek einstellen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_enableAxlib(const rk_aiq_sys_ctx_t* ctx,
                                const int algo_type,
                                const int lib_id,
                                bool enable);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

【Hinweis】

Wenn lib_id der aktuell ausgeführten Algorithmusbibliothek entspricht, kann diese Funktion in jedem Zustand außer dem nicht initialisierten aufgerufen werden.

In anderen Fällen darf sie nur im vorbereiteten Zustand aufgerufen werden. Die durch algo_type bezeichnete Algorithmusbibliothek wird dann durch die neue Bibliothek mit der Kennung lib_id ersetzt.

3.2.12 rk_aiq_uapi2_sysctl_getAxlibStatus

【Beschreibung】 Zustand der Algorithmusbibliothek abrufen.

【Syntax】

 bool
 rk_aiq_uapi2_sysctl_getAxlibStatus(const rk_aiq_sys_ctx_t* ctx,
                                   const int algo_type,
                                   const int lib_id);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

3.2.13 rk_aiq_uapi2_sysctl_getEnabledAxlibCtx

【Beschreibung】 Kontextstruktur der aktivierten Algorithmusbibliothek abrufen.

【Syntax】

 const RkAiqAlgoContext*
 rk_aiq_uapi2_sysctl_getEnabledAxlibCtx(const rk_aiq_sys_ctx_t* ctx, const int
 algo_type);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

【Hinweis】

Die zurückgegebene Algorithmuskontextstruktur wird von internen privaten Funktionen verwendet. Bei benutzerdefinierten Algorithmusbibliotheken muss diese Funktion nach rk_aiq_uapi2_sysctl_enableAxlib aufgerufen werden; andernfalls wird NULL zurückgegeben.

3.2.14 rk_aiq_uapi2_sysctl_setCpsLtCfg

【Beschreibung】 Steuerinformationen für die Zusatzbeleuchtung einstellen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_setCpsLtCfg(const rk_aiq_sys_ctx_t* ctx,
                        rk_aiq_cpsl_cfg_t* cfg);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

3.2.15 rk_aiq_uapi2_sysctl_getCpsLtInfo

【Beschreibung】 Steuerinformationen der Zusatzbeleuchtung abrufen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_getCpsLtInfo(const rk_aiq_sys_ctx_t* ctx,
                        rk_aiq_cpsl_info_t* info);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

3.2.16 rk_aiq_uapi2_sysctl_queryCpsLtCap

【Beschreibung】 Unterstützte Fähigkeiten der Zusatzbeleuchtung abfragen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_queryCpsLtCap(const rk_aiq_sys_ctx_t* ctx,
                        rk_aiq_cpsl_cap_t* cap);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

3.2.17 rk_aiq_uapi2_sysctl_getBindedSnsEntNmByVd

【Beschreibung】 Den zum Videoknoten gehörenden Sensor-Entitätsnamen abfragen.

【Syntax】

 const char* rk_aiq_uapi2_sysctl_getBindedSnsEntNmByVd(const char* vd);

【Parameter】

【Rückgabewert】

【Hinweis】

Der Parameter muss der Pfad des ISPP-Skalierungsknotens sein.

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

3.2.18 rk_aiq_uapi2_sysctl_updateIq

【Beschreibung】 Die aktuell verwendete IQ-Parameterdatei dynamisch aktualisieren, ohne den Datenfluss anzuhalten.

【Syntax】

 XCamReturn rk_aiq_uapi2_sysctl_updateIq(const rk_aiq_sys_ctx_t* sys_ctx, char*
 iqfile);

【Parameter】

【Rückgabewert】

【Hinweis】

iqfile muss ein vollständiger Pfad sein.

Das Aktualisieren der IQ-Parameter ermöglicht keinen Wechsel der Betriebsart; beispielsweise lässt sich zwischen HDR und Normal nicht allein durch Aktualisieren der IQ-Datei umschalten. Einige Funktionen können jedoch durch unterschiedliche IQ-Parameterkonfigurationen umgeschaltet werden, beispielsweise erfolgt der Tag-/Nachtwechsel vollständig über die IQ-Konfiguration.

Beim IQ-Wechsel überschreiben die IQ-Konfigurationsparameter die Einstellungen der Benutzer-API. Beispielsweise kann das AWB-Modul in IQ auf manuellen oder automatischen Modus eingestellt werden. Nach Ausführung dieser Funktion wird der aktuelle AWB-Modus unabhängig von seiner bisherigen Einstellung durch die Standardkonfiguration der neuen IQ-Datei überschrieben.

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_sysctl.h

Bibliotheksdatei: librkaiq.so

3.2.19 rk_aiq_uapi2_sysctl_getCrop

【Beschreibung】 Zuschnittparameter abrufen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_sysctl_getCrop(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_rect_t
 *rect);

【Parameter】

【Rückgabewert】

3.3 Datentypen

3.3.1 rk_aiq_working_mode_t

【Beschreibung】 Betriebsart der AIQ-Pipeline

【Definition】

 typedef enum {
     RK_AIQ_WORKING_MODE_NORMAL,
     RK_AIQ_WORKING_MODE_ISP_HDR2    = 0x10,
     RK_AIQ_WORKING_MODE_ISP_HDR3    = 0x20,
 } rk_aiq_working_mode_t;

【Felder】

【Vorsichtsmaßnahmen】

Fragen Sie zuerst die von Sensor und AIQ unterstützten Modi ab. Wird der eingestellte Modus nicht unterstützt, ist die Einstellung unwirksam.

3.3.2 rk_aiq_static_info_t

【Beschreibung】 Statische AIQ-Informationen

【Definition】

 typedef struct {
     rk_aiq_sensor_info_t    sensor_info;
     rk_aiq_lens_info_t      lens_info;
     bool has_lens_vcm;
     bool has_fl;
     bool fl_strth_adj_sup;
     bool has_irc;
     bool fl_ir_strth_adj_sup;
 } rk_aiq_static_info_t;

【Felder】

3.3.3 rk_aiq_sensor_info_t

【Beschreibung】 Sensorinformationen

【Definition】

 typedef struct {
     char sensor_name[32];
     rk_frame_fmt_t  support_fmt[SUPPORT_FMT_MAX];
     int32_t num;
     /* binded pp stream media index */
     int8_t binded_strm_media_idx;
 } rk_aiq_sensor_info_t;

【Felder】

3.3.4 rk_aiq_module_id_t

【Beschreibung】 AIQ-Modul-ID

【Definition】

 typedef enum {
     RK_MODULE_INVAL = 0,
     RK_MODULE_DPCC,
     RK_MODULE_BLS,
     RK_MODULE_LSC,
     RK_MODULE_AWB_GAIN,
     RK_MODULE_CTK,
     RK_MODULE_GOC,
     RK_MODULE_SHARP,
     RK_MODULE_AE,
     RK_MODULE_AWB,
     RK_MODULE_NR,
     RK_MODULE_GIC,
     RK_MODULE_3DLUT,
     RK_MODULE_LDCH,
     RK_MODULE_TNR,
     RK_MODULE_FEC,
     RK_MODULE_MAX
 }rk_aiq_module_id_t;

【Felder】

3.3.5 rk_aiq_cpsl_cfg_t

【Beschreibung】 Struktur zum Einstellen der Zusatzbeleuchtungsinformationen

【Definition】

 typedef struct rk_aiq_cpsl_cfg_s {
     RKAiqOPMode_t mode;
     rk_aiq_cpsls_t lght_src;
     bool gray_on; /*!< force to gray if light on */
     union {
         struct {
             float sensitivity; /*!< Range [0-100] */
             uint32_t sw_interval; /*!< switch interval time, unit  seconds */
         } a; /*< auto mode */
         struct {
             uint8_t on; /*!< disable 0, enable 1 */
             float strength_led; /*!< Range [0-100] */
             float strength_ir; /*!< Range [0-100] */
         } m; /*!< manual mode */
     } u;
 } rk_aiq_cpsl_cfg_t;

【Felder】

3.3.6 rk_aiq_cpsl_info_t

【Beschreibung】 Struktur zum Abfragen der Zusatzbeleuchtungsinformationen

【Definition】

 typedef struct rk_aiq_cpsl_info_s {
     int32_t mode;
     uint8_t on;
     bool gray;
     float strength_led;
     float strength_ir;
     float sensitivity;
     uint32_t sw_interval;
     int32_t lght_src;
 } rk_aiq_cpsl_info_t;

【Felder】

3.3.7 rk_aiq_cpsl_cap_t

【Beschreibung】 Struktur der unterstützten Zusatzbeleuchtungsfähigkeiten

【Definition】

 typedef struct rk_aiq_cpsl_cap_s {
     int32_t supported_modes[RK_AIQ_OP_MODE_MAX];
     uint8_t modes_num;
     int32_t supported_lght_src[RK_AIQ_CPSLS_MAX];
     uint8_t lght_src_num;
     rk_aiq_range_t strength_led;
     rk_aiq_range_t sensitivity;
     rk_aiq_range_t strength_ir;
 } rk_aiq_cpsl_cap_t;

【Felder】

3.3.8 rk_aiq_rect_t

【Beschreibung】 Zuschnittparameterstruktur definieren

【Definition】

 typedef struct rk_aiq_rect_s {
     int left;
     int top;
     int width;
     int height;
 } rk_aiq_rect_t;

【Felder】

4. Offline-Bildverarbeitung

4.1 Überblick

RKAIQ stellt eine Funktion zur Offline-Verarbeitung von RAW-Bildern bereit: Dateien im RK-eigenen RAW-Format werden von RKAIQ ausgewertet, zur Verarbeitung an ISP gesendet und als Bilder mit normaler Darstellung ausgegeben.

Hinweis: Die Offline-Bildverarbeitungsfunktion wurde nicht getestet.

4.2 Funktionsblockdiagramm

Blockdiagramm der Offline-Bildverarbeitung

4.3 Funktionsbeschreibung

Unterstützt RK-RAW-Dateieingabe. Bei Verwendung der Dateieingabeschnittstelle wird der aufrufende Prozess blockiert, bis die Datei vollständig verarbeitet und erfolgreich ausgegeben wurde.

Unterstützt RK-RAW-Puffereingabe im asynchronen Verarbeitungsmodus. Bei Verwendung der Puffereingabeschnittstelle wird der aufrufende Prozess nicht blockiert. Nach Abschluss der Pufferverarbeitung wird die Callback-Funktion aufgerufen, sofern eine registriert ist.

Unterstützt RK-RAW-Puffereingabe im synchronen Verarbeitungsmodus. Bei Verwendung der Puffereingabeschnittstelle wird der aufrufende Prozess blockiert, bis der Puffer vollständig verarbeitet und erfolgreich ausgegeben wurde.

4.4 Beschreibung des RK-RAW-Formats

Siehe Dokumentation des RK-RAW-Dateiformats.

4.5 Unterstützte RAW-Formate

Unterstützt raw8/raw10/raw12 sowie die vier Bayer-Formate BGGR/GBRG/GRBG/RGGB.

4.6 API-Referenz

4.7 Datenstrukturen

4.8 Hinweise

Bei Verwendung der RK-Raw-Datenverarbeitung muss beim Erstellen eines AIQ-Kontexts der Parameter sns_ent_name der Schnittstelle rk_aiq_uapi2_sysctl_init “FakeCamera” lauten.

Die RAW-Datenverarbeitung benötigt IQ-XML-Bildparameterdateien. Die XML-Datei muss für dieselbe Auflösung wie die eingehenden RK-Raw-Bilddaten erzeugt werden. Die Bildparameterdatei muss FakeCamera.xml heißen und im XML-Ladepfad abgelegt werden.

4.9 Referenzbeispiel

Weitere Informationen zur Verwendung der Offline-Bildverarbeitungs-API enthält rkisp_demo unter YOUR_SDK_DIR/external/camera_engine_rkaiq/rkisp_demo.

5. Kameragruppe

5.1 Überblick

Beispielsweise müssen bei Rundumsichtanwendungen mehrere Kameras zur gemeinsamen Verwaltung gruppiert und Parameter wie die Belichtung einheitlich eingestellt werden. Dazu lässt sich eine Gruppe anlegen und mehrere Kameras derselben Gruppe zuordnen. Die Camera-Group-API basiert auf der AIQ-API einer Einzelkamera. Sofern nicht anders angegeben, gelten APIs für einen einzelnen AIQ-Kontext auch für eine Kameragruppe. Die interne AIQ-Implementierung verteilt Anfragen je nach Typ des übergebenen Kontexts an eine Kameragruppe oder eine Einzelkamera.

5.1.1 rk_aiq_uapi2_camgroup_create

【Beschreibung】 Beim Erstellen einer Kameragruppe wird für jede Kamera ein eigener AIQ ctx erstellt und anschließend zur Verwaltung an Group Ctx übergeben.

【Syntax】

 rk_aiq_camgroup_ctx_t*
 rk_aiq_uapi2_camgroup_create (rk_aiq_camgroup_instance_cfg_t* cfg);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_camgroup.h

Bibliotheksdatei: librkaiq.so

【Hinweis】

Im Unterschied dazu erzeugt rk_aiq_uapi2_sysctl_init eine AIQ-Laufzeitumgebung für eine Einzelkamera. Wenn eine Sensorentität mit rk_aiq_uapi2_sysctl_init eine Laufzeitumgebung erhält, darf sie nicht zusätzlich über rk_aiq_uapi2_camgroup_create eine Gruppenlaufzeitumgebung erhalten, und umgekehrt.

Da die standardmäßige IQ-Szene normal-day lautet, müssen HDR oder andere Modi vorab mit rk_aiq_uapi2_sysctl_preInit_scene eingestellt werden.

5.1.2 rk_aiq_uapi2_camgroup_prepare

【Beschreibung】 Entsprechend dem gewählten Pipeline-Modus Initialisierungsparameter erzeugen und Pipelines anlegen. Für den AIQ ctx jeder Kamera wird rk_aiq_uapi2_sysctl_prepare aufgerufen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_camgroup_prepare (rk_aiq_camgroup_ctx_t* camgroup_ctx,
 rk_aiq_working_mode_t mode);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_camgroup.h; Bibliotheksdatei: librkaiq.so

5.1.3 rk_aiq_uapi2_camgroup_start

【Beschreibung】 Kameragruppe ausführen. Für den AIQ ctx jeder Kamera wird rk_aiq_uapi2_sysctl_start aufgerufen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_camgroup_start (rk_aiq_camgroup_ctx_t* camgroup_ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_camgroup.h; Bibliotheksdatei: librkaiq.so

5.1.4 rk_aiq_uapi2_camgroup_stop

【Beschreibung】 Kameragruppe stoppen. Für den AIQ ctx jeder Kamera wird rk_aiq_uapi2_sysctl_stop aufgerufen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_camgroup_stop (rk_aiq_camgroup_ctx_t* camgroup_ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_camgroup.h; Bibliotheksdatei: librkaiq.so

5.1.5 rk_aiq_uapi2_camgroup_destroy

【Beschreibung】 Kameragruppe zerstören. Für den AIQ ctx jeder Kamera wird rk_aiq_uapi2_sysctl_deinit aufgerufen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_camgroup_destroy (rk_aiq_camgroup_ctx_t* camgroup_ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_camgroup.h; Bibliotheksdatei: librkaiq.so

5.1.6 rk_aiq_uapi2_camgroup_getOverlapMap

【Beschreibung】 Im Rundumsichtszenario Überlappungsbereichsinformationen jeder Kamera aus dem CameraGroup-Kontext abrufen.

【Syntax】

 struct RK_PS_SrcOverlapMap*
 rk_aiq_uapi2_camgroup_getOverlapMap (rk_aiq_camgroup_ctx_t* camgroup_ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_camgroup.h; Bibliotheksdatei: librkaiq.so

5.1.7 rk_aiq_uapi2_camgroup_getOverlapMap

【Beschreibung】 Im Rundumsichtszenario Überlappungsbereichsinformationen jeder Kamera aus einer Datei abrufen.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_camgroup_getOverlapMap_from_file (const char* map_file,
                                                             struct
 RK_PS_SrcOverlapMap** overlapMap);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_camgroup.h; Bibliotheksdatei: librkaiq.so

5.1.8 rk_aiq_uapi2_camgroup_getAiqCtxBySnsNm

【Beschreibung】 Den AIQ-Kontext einer Einzelkamera über den Sensor-Entitätsnamen innerhalb der Gruppe abrufen.

【Syntax】

 rk_aiq_sys_ctx_t*
 rk_aiq_uapi2_camgroup_getAiqCtxBySnsNm (rk_aiq_camgroup_ctx_t* camgroup_ctx,
 const char* sns_entity_name);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_camgroup.h; Bibliotheksdatei: librkaiq.so

5.1.9 rk_aiq_uapi2_camgroup_getCamInfos

【Beschreibung】 Informationen zu den Kameras in der Gruppe abrufen, beispielsweise den Namen der Sensorentität.

【Syntax】

 XCamReturn
 rk_aiq_uapi2_camgroup_getCamInfos (rk_aiq_camgroup_ctx_t* camgroup_ctx,
                    rk_aiq_camgroup_camInfos_t* camInfos);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_camgroup.h; Bibliotheksdatei: librkaiq.so

5.1.10 rk_aiq_uapi2_camgroup_bind

【Beschreibung】 Reservierte Schnittstelle, nicht implementiert.

5.1.11 rk_aiq_uapi2_camgroup_unbind

【Beschreibung】 Reservierte Schnittstelle, nicht implementiert.

5.2 Datenstrukturen

5.2.1 rk_aiq_camgroup_instance_cfg_t

【Erläuterung】 Carmelaghrup-Konfigurationsparameter

【Definition】

   typedef struct rk_aiq_camgroup_instance_cfg_s {
       const char* sns_ent_nm_array[RK_AIQ_CAM_GROUP_MAX_CAMS];
       int sns_num;
       const char* config_file_dir;
        /* followings are relative path to config_file_dir */
        const char* single_iq_file;
        const char* group_iq_file;
        const char* overlap_map_file;
    } rk_aiq_camgroup_instance_cfg_t;

【Felder】

5.2.2 rk_aiq_camgroup_camInfos_t

【Erläuterung】 Informationen zu jeder Kamera in der Kameragruppe

【Definition】

    typedef struct rk_aiq_camgroup_camInfos_s {
        int valid_sns_num;
        const char* sns_ent_nm[RK_AIQ_CAM_GROUP_MAX_CAMS];
        int sns_camPhyId[RK_AIQ_CAM_GROUP_MAX_CAMS];
   } rk_aiq_camgroup_camInfos_t;

【Felder】

5.2.3 struct RK_PS_SrcOverlapMap

【Erläuterung】 Überlappungsbereich der Kamera definieren

【Definition】

        struct RK_PS_SrcOverlapMap
      {
            char versionInfo[64];
            RK_PS_SrcOverlapPosition srcOverlapPositon[8];
            unsigned char overlapMap[15 * 15 * 8];
        };

【Felder】

6. AE

6.1 Überblick

Das AE-Modul ermittelt die Belichtung des aktuellen Bildes anhand des automatischen Belichtungsmesssystems und konfiguriert anschließend Objektivblende, Sensorverschluss und Verstärkung automatisch, um die beste Bildqualität zu erzielen.

6.2 Wichtige Begriffe

Belichtungszeit: Die Zeit, in der der Sensor Ladung sammelt, also der Zeitraum zwischen der Belichtung des Sensorpixels und dem Auslesen seiner Ladung.

Belichtungsverstärkung: Gesamter Verstärkungsfaktor der vom Sensor ausgegebenen Ladung, gewöhnlich bestehend aus digitaler und analoger Verstärkung. Analoge Verstärkung verursacht etwas weniger Rauschen und wird daher im Allgemeinen bevorzugt.

Blende: Mechanismus im Objektiv, der die Größe der freien Öffnung verändert.

Flimmerunterdrückung: Bildflimmern durch eine Abweichung zwischen der Netzfrequenz der Lampe und der Sensorbildrate wird gewöhnlich durch Begrenzung der Belichtungszeit und Änderung der Sensorbildrate unterdrückt.

6.3 Funktionsbeschreibung

Das AE-Modul besteht aus AE-Statistik und dem Algorithmus der AE-Steuerstrategie.

6.4 Referenz der funktionsbezogenen APIs

6.4.1 rk_aiq_uapi2_setAeLock

【Beschreibung】

AE-Belichtungssperre einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setAeLock（const rk_aiq_sys_ctx_t* ctx, bool on);

【Parameter】

【Rückgabewert】

6.4.2 rk_aiq_uapi2_setExpMode

【Beschreibung】 Belichtungsmodus einstellen; automatische und manuelle Belichtung werden unterstützt.

【Syntax】

 XCamReturn rk_aiq_uapi2_setExpMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode);

【Parameter】

【Rückgabewert】

【Hinweis】

Beim Wechsel in den manuellen Belichtungsmodus werden für Verstärkung und Belichtungszeit die in der Bildparameterdatei definierten Anfangswerte verwendet. Um den Belichtungswert gleichzeitig mit dem Wechsel in den manuellen Modus einzustellen, kann rk_aiq_uapi2_setManualExp verwendet werden.

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.3 rk_aiq_uapi2_getExpMode

【Beschreibung】 Belichtungsmodus abrufen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getExpMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.4 rk_aiq_uapi2_setManualExp

【Beschreibung】 Manuellen Belichtungsmodus verwenden und Verstärkung sowie Belichtungszeit einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setManualExp(const rk_aiq_sys_ctx_t* ctx, float gain,
 float time);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.5 rk_aiq_uapi2_setExpGainRange

【Beschreibung】** Verstärkungsbereich einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setExpGainRange(const rk_aiq_sys_ctx_t* ctx, paRange_t
 *gain);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.6 rk_aiq_uapi2_getExpGainRange

【Beschreibung】 Verstärkungsbereich abrufen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getExpGainRange(const rk_aiq_sys_ctx_t* ctx, paRange_t
 *gain);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.7 rk_aiq_uapi2_setExpTimeRange

【Beschreibung】 Belichtungszeitbereich einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setExpTimeRange(const rk_aiq_sys_ctx_t* ctx, paRange_t
 *time);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.8 rk_aiq_uapi2_getExpTimeRange

【Beschreibung】 Belichtungszeitbereich abrufen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getExpTimeRange(const rk_aiq_sys_ctx_t* ctx, paRange_t
 *time);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.9 rk_aiq_uapi2_setBLCMode

【Beschreibung】 Gegenlichtkompensation ein-/ausschalten und Bereich auswählen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setBLCMode(const rk_aiq_sys_ctx_t* ctx, bool on,
 aeMeasAreaType_t areaType);

【Parameter】

【Rückgabewert】

【Hinweis】

Diese Schnittstelle ist nur im linearen Modus verfügbar.

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.10 rk_aiq_uapi2_setBLCStrength

【Beschreibung】 Stärke der Aufhellung dunkler Bereiche einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setBLCStrength(const rk_aiq_sys_ctx_t* ctx, int
 strength);

【Parameter】

【Rückgabewert】

【Hinweis】

Diese Schnittstelle ist nur im linearen Modus verfügbar.

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.11 rk_aiq_uapi2_setHLCMode

【Beschreibung】 Spitzlichtunterdrückung ein-/ausschalten.

【Syntax】

 XCamReturn rk_aiq_uapi2_setHLCMode(const rk_aiq_sys_ctx_t* ctx, bool on);

【Parameter】

【Rückgabewert】

【Hinweis】

Diese Schnittstelle ist nur im linearen Modus verfügbar.

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.12 rk_aiq_uapi2_setHLCStrength

【Beschreibung】 Stärke der Spitzlichtunterdrückung einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setHLCStrength(const rk_aiq_sys_ctx_t* ctx, int
 strength);

【Parameter】

【Rückgabewert】

【Hinweis】

Diese Schnittstelle ist nur im linearen Modus verfügbar.

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.sov

6.4.13 rk_aiq_uapi2_setAntiFlickerEn

【Beschreibung】 Unterdrückung netzfrequenzbedingten Flimmerns ein-/ausschalten.

【Syntax】

 XCamReturn rk_aiq_uapi2_setAntiFlickerEn(const rk_aiq_sys_ctx_t* ctx, bool on)；

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.14 rk_aiq_uapi2_getAntiFlickerEn

【Beschreibung】 Unterdrückung netzfrequenzbedingten Flimmerns ein-/ausschalten.

【Syntax】

 XCamReturn rk_aiq_uapi2_getAntiFlickerEn(const rk_aiq_sys_ctx_t* ctx, bool* on)；

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.15 rk_aiq_uapi2_setAntiFlickerMode

【Beschreibung】 Modus der Flimmerunterdrückung einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setAntiFlickerMode(const rk_aiq_sys_ctx_t* ctx,
 antiFlickerMode_t mode);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.16 rk_aiq_uapi2_getAntiFlickerMode

【Beschreibung】 Modus der Flimmerunterdrückung abrufen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getAntiFlickerMode(const rk_aiq_sys_ctx_t* ctx,
 antiFlickerMode_t *mode);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.17 rk_aiq_uapi2_setExpPwrLineFreqMode

【Beschreibung】 Frequenz der Flimmerunterdrückung einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setExpPwrLineFreqMode(const rk_aiq_sys_ctx_t* ctx,
 expPwrLineFreq_t freq);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.4.18 rk_aiq_uapi2_getExpPwrLineFreqMode

【Beschreibung】** Frequenz der Flimmerunterdrückung abrufen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getExpPwrLineFreqMode(const rk_aiq_sys_ctx_t* ctx,
 expPwrLineFreq_t *freq);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

6.5 Datentypen der funktionsbezogenen APIs

6.5.1 opMode_t

【Beschreibung】 Automatischen und manuellen Modus definieren.

【Definition】

 typedef enum opMode_e {
     OP_AUTO = 0,
     OP_MANUALl = 1,
     OP_INVAL
 } opMode_t;

【Felder】

6.5.2 paRange_t

【Beschreibung】 Parameterbereiche definieren.

【Definition】

 typedef struct paRange_s {
     float max;
     float min;
 } paRange_t;

【Felder】

6.5.3 aeMeasAreaType_t

【Beschreibung】 Typ des AE-Messbereichs definieren.

【Definition】

 typedef enum aeMeasAreaType_e {
     AE_MEAS_AREA_AUTO = 0,
     AE_MEAS_AREA_UP,
     AE_MEAS_AREA_BOTTOM,
     AE_MEAS_AREA_LEFT,
     AE_MEAS_AREA_RIGHT,
     AE_MEAS_AREA_CENTER,
 } aeMeasAreaType_t;

【Felder】

6.5.4 expPwrLineFreq_t

【Beschreibung】 Frequenz der Flimmerunterdrückung definieren.

【Definition】

 typedef enum expPwrLineFreq_e {
        EXP_PWR_LINE_FREQ_DIS   = 0,
        EXP_PWR_LINE_FREQ_50HZ  = 1,
        EXP_PWR_LINE_FREQ_60HZ  = 2,
 } expPwrLineFreq_t;

【Felder】

6.5.5 antiFlickerMode_t

【Beschreibung】 Modus der Flimmerunterdrückung definieren.

【Definition】

 typedef enum antiFlickerMode_e {
     ANTIFLICKER_NORMAL_MODE = 0,
     ANTIFLICKER_AUTO_MODE = 1,
 } antiFlickerMode_t;

【Felder】

6.6 Referenz der modulbezogenen APIs

6.6.1 rk_aiq_user_api2_ae_setExpSwAttr

【Beschreibung】 Softwareeigenschaften der AE-Belichtung einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_setExpSwAttr(const rk_aiq_sys_ctx_t* ctx,
                                 const Uapi_ExpSwAttrV2_t expSwAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Eigenschaften für manuelle Belichtung einstellen

Zu den Belichtungskomponenten gehören Sensorbelichtungszeit, Sensorbelichtungsverstärkung und digitale ISP-Verstärkung. Nach Auswahl des manuellen Belichtungsmodus müssen außerdem für jede Komponente der manuelle Zustand (ManualGainEn, ManualTimeEn, ManualIspDgainEn) und der zugehörige manuelle Wert eingestellt werden. Im manuellen Belichtungsmodus müssen alle Belichtungskomponenten manuell sein; ihre Werte werden durch Sensor und Objektiv begrenzt. Überschreitet ein eingestellter Komponentenwert die Sensorgrenze, korrigiert ihn der Algorithmus automatisch.

 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
 //LinearAE
 expSwAttr.stManual.LinearAE.ManualGainEn = true;
 expSwAttr.stManual.LinearAE.ManualTimeEn = true;
 expSwAttr.stManual.LinearAE.GainValue = 1.0f; /*gain = 1x*/
 expSwAttr.stManual.LinearAE.TimeValue = 0.02f; /*time = 1/50s*/
 //HdrAE (should set all frames)
 expSwAttr.stManual.HdrAE.ManualGainEn = true;
 expSwAttr.stManual.HdrAE.ManualTimeEn = true;
 expSwAttr.stManual.HdrAE.GainValue[0] = 1.0f; /*sframe gain = 1x*/
 expSwAttr.stManual.HdrAE.TimeValue[0] = 0.002f; /*sframe time = 1/500s*/
 expSwAttr.stManual.HdrAE.GainValue[1] = 2.0f; /*mframe gain = 2x*/
 expSwAttr.stManual.HdrAE.TimeValue[1] = 0.01f; /*mframe time = 1/100s*/
 expSwAttr.stManual.HdrAE.GainValue[2] = 4.0f; /*lframe gain = 4x*/
 expSwAttr.stManual.HdrAE.TimeValue[2] = 0.02f; /*lframe time = 1/50s*/
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

Eigenschaften für automatische Belichtung einstellen

Bei automatischer Belichtung kann der Bereich der Belichtungskomponenten eingestellt werden. Überschreitet dieser die Sensorgrenzen, korrigiert ihn der Algorithmus automatisch.

【Hinweis】: Die Parameter zum Einstellen des Belichtungskomponentenbereichs unterscheiden sich von den Parametern zum Abrufen dieses Bereichs.

 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.AecOpType = RK_AIQ_OP_MODE_AUTO;
 //set time range in struct "stAdvanced"
 expSwAttr.stAdvanced.SetAeRangeEn = true;/*must enable*/
 //LinAE
 expSwAttr.stAdvanced.SetLinAeRange.stExpTimeRange.Max = 0.04f; /*time_max =
 0.04*/
 expSwAttr.stAdvanced.SetLinAeRange.stExpTimeRange.Min = 0.001f; /*time_min =
 0.001*/
 //HdrAE
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[0].Max = 0.002f; /*sframe
 time_max = 0.02*/
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[0].Min = 0.001f; /*sframe
 time_min = 0.01*/
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[1].Max = 0.003f; /*mframe
 time_max = 0.03*/
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[1].Min = 0.002f; /*mframe
 time_min = 0.02*/
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[2].Max = 0.04f; /*lframe
 time_max = 0.03*/
 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[2].Min = 0.03f; /*lframe
 time_min = 0.02*/
 //get time range in struct "stAuto"
 printf("linear time range=[%f,%f]\n",
     expSwAttr.stAuto.LinAeRange.stExpTimeRange.Min,
 expSwAttr.stAuto.LinAeRange.stExpTimeRange.Max);
 printf("hdr stime range=[%f,%f], mtime range=[%f,%f], ltime range=[%f,%f]\n",
     expSwAttr.stAuto.HdrAeRange.stExpTimeRange[0].Min,
 expSwAttr.stAuto.HdrAeRange.stExpTimeRange[0].Max,
     expSwAttr.stAuto.HdrAeRange.stExpTimeRange[1].Min,
 expSwAttr.stAuto.HdrAeRange.stExpTimeRange[1].Max,
     expSwAttr.stAuto.HdrAeRange.stExpTimeRange[2].Min,
 expSwAttr.stAuto.HdrAeRange.stExpTimeRange[2].Max);
 //set gain range in struct "stAdvanced"
 expSwAttr.stAdvanced.SetAeRangeEn = true;/*must enable*/
 //LinAE
 expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Max = 32.0f; /*gain_max = 32x*/
 expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Min = 1.0f; /*gain_min = 1x*/
 //HdrAE
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Max = 32.0f; /*sframe gain_max
 = 2x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Min = 1.0f; /*sframe gain_min =
 1x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[1].Max = 64.0f; /*mframe gain_max
 = 64x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[1].Min = 1.0f; /*mframe gian_min =
 1x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[2].Max = 64.0f; /*lframe gain_max
 = 64x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[2].Min = 1.0f; /*lframe gain_min =
 1x*/
 //get gain range in struct "stAuto"
 printf("linear gain range=[%f,%f]\n",
     expSwAttr.stAuto.LinAeRange.stGainRange.Min,
 expSwAttr.stAuto.LinAeRange.stGainRange.Max);
 printf("hdr sgain range=[%f,%f], mgain range=[%f,%f], lgain range=[%f,%f]\n",
     expSwAttr.stAuto.HdrAeRange.stGainRange[0].Min,
 expSwAttr.stAuto.HdrAeRange.stGainRange[0].Max,
     expSwAttr.stAuto.HdrAeRange.stGainRange[1].Min,
 expSwAttr.stAuto.HdrAeRange.stGainRange[1].Max,
     expSwAttr.stAuto.HdrAeRange.stGainRange[2].Min,
 expSwAttr.stAuto.HdrAeRange.stGainRange[2].Max);
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

Eigenschaften für halbmanuelle Belichtung einstellen

Halbmanuelle Belichtung bedeutet, dass mindestens eine Belichtungskomponente (Sensorbelichtungszeit, Sensorbelichtungsverstärkung oder digitale ISP-Verstärkung) manuell ist und die übrigen automatisch arbeiten; andernfalls wird mit einem Fehler beendet. Um beispielsweise die Verstärkung manuell und Belichtungszeit sowie digitale ISP-Verstärkung automatisch zu steuern, gibt es zwei Möglichkeiten: Im manuellen Belichtungsmodus die manuelle Aktivierung für Belichtungszeit und digitale ISP-Verstärkung auf false, für Belichtungsverstärkung auf true setzen und den gewünschten manuellen Wert einstellen. Methode 2: Im automatischen Belichtungsmodus den maximalen und minimalen Verstärkungswert auf den festzulegenden Wert setzen.

【Hinweis】Methode 1: Im HDR-Belichtungsmodus ist das manuelle Verhalten aller Bilder synchron, d. h. die entsprechenden Komponenten jedes Bildes besitzen denselben manuellen Zustand. Zugleich muss die maximale Belichtung langer Bilder größer als die maximale Belichtung kurzer Bilder und die minimale Belichtung langer Bilder größer als die minimale Belichtung kurzer Bilder sein. Methode 2: Im HDR-Belichtungsmodus darf das manuelle Verhalten der Bilder unterschiedlich sein, beispielsweise manuelle Verstärkung kurzer Bilder bei automatischer Verstärkung langer Bilder. Auch hierbei muss die maximale Belichtung langer Bilder größer als die maximale Belichtung kurzer Bilder und die minimale Belichtung langer Bilder größer als die minimale Belichtung kurzer Bilder sein.

 //Method One
 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
 //LinearAE
 expSwAttr.stManual.LinearAE.ManualGainEn = true;
 expSwAttr.stManual.LinearAE.ManualTimeEn = false;
 expSwAttr.stManual.LinearAE.ManualIspDgainEn = false;
 expSwAttr.stManual.LinearAE.GainValue = 2.0f; /*gain = 2x*/
 //HdrAE (need to set all frames)
 expSwAttr.stManual.HdrAE.ManualGainEn = true;
 expSwAttr.stManual.HdrAE.ManualTimeEn = false;
 expSwAttr.stManual.HdrAE.ManualIspDgainEn = false;
 expSwAttr.stManual.HdrAE.GainValue[0] = 1.0f; /*sframe gain = 1x*/
 expSwAttr.stManual.HdrAE.GainValue[1] = 2.0f; /*mframe gain = 2x*/
 expSwAttr.stManual.HdrAE.GainValue[2] = 4.0f; /*lframe gain = 4x*/
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);
 //Method Two
 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.AecOpType = RK_AIQ_OP_MODE_AUTO;
 //set gain range
 expSwAttr.stAdvanced.SetAeRangeEn = true;/*Must be enabled*/
 //LinAE
 expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Max = 2.0f; /*gain_max = 2x*/
 expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Min = 2.0f;  /*gain_min = 2x*/
 //HdrAE (allow to set only one frame)
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Max = 2.0f; /*sframe gain_max =
 2x*/
 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Min = 2.0f;  /*sframe gain_min
 = 2x*/
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

Feste Bildrate oder automatische Bildratenreduzierung einstellen

Im Modus mit fester Bildrate darf die zulässige Bildrate die vom Treiber definierte maximale Bildrate nicht überschreiten. Andernfalls erscheint ein Protokollhinweis und die Bildrateneinstellung wird deaktiviert.

 //set fixed framemode
 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.stAuto.stFrmRate.isFpsFix = true;
 expSwAttr.stAuto.stFrmRate.FpsValue = 25; /*fps = 25*/
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);
 //set auto framemode
 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 expSwAttr.stAuto.stFrmRate.isFpsFix = false;
 /*Generally, the automatic frame reduction mode is configured by tuning personnel
 in advance with the minimum frame rate and the gain value corresponding to the
 switching frame rate*/
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

Geschwindigkeit der Belichtungsanpassung und Verzögerung in Bildern einstellen

 Uapi_ExpSwAttrV2_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 //set ae speed
 expSwAttr.stAuto.stAeSpeed.DampOver = 0.8f;
 expSwAttr.stAuto.stAeSpeed.DampDark2Bright = 0.8f;
 expSwAttr.stAuto.stAeSpeed.DampUnder = 0.8f;
 expSwAttr.stAuto.stAeSpeed.DampBright2Dark = 0.8f;
 //set ae delay
 expSwAttr.stAuto.BlackDelayFrame = 2;
 expSwAttr.stAuto.WhiteDelayFrame = 4;
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

Flimmerunterdrückung konfigurieren

 Uapi_ExpSwAttr_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 //set antifilicker mode
 expSwAttr.stAuto.stAntiFlicker.enable = true;
 expSwAttr.stAuto.stAntiFlicker.Frequency = AECV2_FLICKER_FREQUENCY_50HZ;
 expSwAttr.stAuto.stAntiFlicker.Mode = AECV2_ANTIFLICKER_AUTO_MODE;
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

AE-Gewichtung einstellen

Stellen Sie eine 15X15-Gewichtung ein; der Algorithmus verdichtet sie entsprechend der tatsächlichen Blockaufteilung der Hardware. Derzeit gibt es zwei Einstellmöglichkeiten: Methode 1: Gewichte direkt in JSON ändern. Methode 2: Gewichte über stadvanced ändern; nach Deaktivierung kann die JSON-Gewichtung wiederhergestellt werden (empfohlene Methode).

Für Gesichtsanwendungen wird empfohlen, beim Erscheinen eines Gesichts expSwAttr.stAdvanced.enable = true zu setzen und die Gewichte in expSwAttr.stAdvanced zu verwenden. Verschwindet das Gesicht, mit expSwAttr.stAdvanced.enable = false wieder die ursprünglichen Gewichte verwenden.

 Uapi_ExpSwAttr_t expSwAttr;
 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
 uint8_t GridWeights[225]={
 0,  0, 1,  2,  2,  3,  4,  5,  4, 3,  2,  2,  1,  0,  0,
 0,  1, 2,  3,  3,  4,  5,  6,  5, 4,  3,  3,  2,  1,  0,
 1,  2, 3,  5,  5,  6,  7,  8,  7, 6,  5,  5,  3,  2,  1,
 2,  3, 5,  7,  7,  8,  9, 10,  9, 8,  7,  7,  5,  3,  2,
 2,  3, 5,  7,  8,  9, 10, 11, 10, 9,  8,  7,  5,  3,  2,
 2,  4, 6,  8,  9, 10, 11, 12, 11,10,  9,  8,  6,  4,  2,
 2,  4, 6,  9, 10, 11, 12, 13, 12,11, 10,  9,  6,  4,  2,
 3,  5 ,7, 10, 11, 12, 13, 14, 13,12, 11, 10,  7,  5,  3,
 2,  4, 6,  9, 10, 11, 12, 13, 12,11, 10,  9,  6,  4,  2,
 2,  4, 6,  8,  9, 10, 11, 12, 11,10,  9,  8,  6,  4,  2,
 2,  3, 5,  7,  8,  9, 10, 11, 10, 9,  8,  7,  5,  3,  2,
 2,  3, 5,  7,  7,  8,  9, 10,  9, 8,  7,  7,  5,  3,  2,
 1,  2, 4,  6,  6,  7,  8,  9,  8, 7,  6,  6,  4,  2,  1,
 0,  1, 3,  5,  5,  6,  7,  8,  7, 6,  5,  5,  3,  1,  0,
 0,  1, 3,  5,  5,  6,  7,  8,  7, 6,  5,  5,  3,  1,  0
 };
 //method one：
 memcpy(expSwAttr.GridWeights.uCoeff, GridWeights,
 sizeof(expSwAttr.GridWeights.uCoeff));
 //method two:
 expSwAttr.stAdvanced.enable = true; //important! true means preferring to use these parameters
 memcpy(expSwAttr.stAdvanced.GridWeights, GridWeights,
 sizeof(expSwAttr.stAdvanced.GridWeights));
 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);

6.6.2 rk_aiq_user_api2_ae_getExpSwAttr

【Beschreibung】 Softwareeigenschaften der AE-Belichtung abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_getExpSwAttr(const rk_aiq_sys_ctx_t* ctx,
                         Uapi_ExpSwAttrV2_t* pExpSwAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

6.6.3 rk_aiq_user_api2_ae_setLinAeRouteAttr

【Beschreibung】 Szenenbezogene AE-Belichtungsverteilungsstrategie im linearen Modus einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_setLinAeRouteAttr(const rk_aiq_sys_ctx_t* ctx, const
 Uapi_LinAeRouteAttr_t linAeRouteAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

 Uapi_LinAeRouteAttr_t LinAeRouteAttr;
 memset(&LinAeRouteAttr,0x00,sizeof(Uapi_LinAeRouteAttr_t));
 rk_aiq_user_api2_ae_getLinAeRouteAttr(sys_ctx,&LinAeRouteAttr);
 int len = 8;
 float TimeDot[8]={0,0.01,0.01,0.02,0.02,0.03,0.03,0.04};
 float GainDot[8]={1,1,4,4,8,8,16,32};
 float IspGainDot[8]={1,1,1,1,1,1,1,1};
 int PirisDot[8]={512,512,512,512,512,512,512,512};
 LinAeRouteAttr.TimeDot_len = len;
 LinAeRouteAttr.GainDot_len = len;
 LinAeRouteAttr.IspDGainDot_len = len;
 LinAeRouteAttr.PIrisDot_len = len;
 LinAeRouteAttr.GainDot = GainDot;
 LinAeRouteAttr.IspDGainDot = IspGainDot;
 LinAeRouteAttr.TimeDot = TimeDot;
 LinAeRouteAttr.PIrisDot = PirisDot;
 rk_aiq_user_api2_ae_setLinAeRouteAttr(sys_ctx,LinAeRouteAttr);

6.6.4 rk_aiq_user_api2_ae_getLinAeRouteAttr

【Beschreibung】 Szenenbezogene AE-Belichtungsverteilungsstrategie im linearen Modus abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_getLinAeRouteAttr(const rk_aiq_sys_ctx_t* ctx,
 Uapi_LinAeRouteAttr_t* pLinAeRouteAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

6.6.5 rk_aiq_user_api2_ae_setHdrAeRouteAttr

【Beschreibung】 Szenenbezogene AE-Belichtungsverteilungsstrategie im HDR-Modus einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_setHdrAeRouteAttr(const rk_aiq_sys_ctx_t* ctx, const
 Uapi_HdrAeRouteAttr_t hdrAeRouteAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

 Uapi_HdrAeRouteAttr_t stHdrRoute;
 memset(&stHdrRoute,0x00,sizeof(Uapi_HdrAeRouteAttr_t));
 ret = rk_aiq_user_api2_ae_getHdrAeRouteAttr(ctx,&stHdrRoute);
 int len = 6;
 float HdrTimeDot[3][6] = {0.0, 0.01, 0.01, 0.01, 0.01, 0.01,
                           0.0, 0.02, 0.02, 0.02, 0.02, 0.02,
                           0.0, 0.03, 0.03, 0.03, 0.03, 0.03};
 float HdrGainDot[3][6] = {1, 1, 4, 6, 8, 12,
                           1, 1, 4, 6, 8, 12,
                           1, 1, 4, 6, 8, 12};
 float HdrIspDGainDot[3][6] = {1, 1, 1, 1, 1, 1,
                               1, 1, 1, 1, 1, 1,
                               1, 1, 1, 1, 1, 1};
 int   HdrPIrisGainDot[6] = {1, 1, 1, 1, 1, 1};
 stHdrRoute.Frm0TimeDot_len = len;
 stHdrRoute.Frm0GainDot_len = len;
 stHdrRoute.Frm0IspDGainDot_len = len;
 stHdrRoute.Frm1TimeDot_len = len;
 stHdrRoute.Frm1GainDot_len = len;
 stHdrRoute.Frm1IspDGainDot_len = len;
 stHdrRoute.Frm2TimeDot_len = len;
 stHdrRoute.Frm2GainDot_len = len;
 stHdrRoute.Frm2IspDGainDot_len = len;
 stHdrRoute.PIrisDot_len = len;
 stHdrRoute.Frm0TimeDot = HdrTimeDot[0];
 stHdrRoute.Frm0GainDot = HdrGainDot[0];
 stHdrRoute.Frm0IspDGainDot = HdrIspDGainDot[0];
 stHdrRoute.Frm1TimeDot = HdrTimeDot[1];
 stHdrRoute.Frm1GainDot = HdrGainDot[1];
 stHdrRoute.Frm1IspDGainDot = HdrIspDGainDot[1];
 stHdrRoute.Frm2TimeDot = HdrTimeDot[2];
 stHdrRoute.Frm2GainDot = HdrGainDot[2];
 stHdrRoute.Frm2IspDGainDot = HdrIspDGainDot[2];
 stHdrRoute.PIrisDot = HdrPIrisGainDot;
 ret = rk_aiq_user_api2_ae_setHdrAeRouteAttr(ctx,stHdrRoute);

6.6.6 rk_aiq_user_api2_ae_getHdrAeRouteAttr

【Beschreibung】 Szenenbezogene AE-Belichtungsverteilungsstrategie im HDR-Modus abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_getHdrAeRouteAttr(const rk_aiq_sys_ctx_t* ctx,
 Uapi_HdrAeRouteAttr_t* pHdrAeRouteAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

6.6.7 rk_aiq_user_api2_ae_setLinExpAttr

【Beschreibung】 AE-Belichtungsparameter im linearen Modus einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_setLinExpAttr(const rk_aiq_sys_ctx_t* ctx, const
 Uapi_LinExpAttrV2_t linExpAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

AE-Belichtungsparameter im linearen Modus einstellen, darunter beispielsweise Helligkeitsanpassung Evbias, Gegenlichtkompensation BackLightCtrl und Spitzlichtunterdrückung OverExpCtrl. Beachten Sie, dass Gegenlichtkompensation und Spitzlichtunterdrückung nicht gleichzeitig aktiviert werden können.

 Uapi_LinExpAttrV2_t linExpAttr;
 memset(&linExpAttr,0,sizeof(Uapi_LinExpAttrV2_t));
 ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &linExpAttr);
 //set Evbias
 printf("Evbias=%f\n", linExpAttr.Evbias);
 linExpAttr.Evbias = 100.0f;
 //set BackLightCtrl
 linExpAttr.BackLightCtrl.Enable = true;
 linExpAttr.BackLightCtrl.StrBias = 200.0f;
 //set OverExpCtrl
 linExpAttr.OverExpCtrl.Enable = true;
 linExpAttr.OverExpCtrl.StrBias = 100.0f;
 ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, linExpAttr);

6.6.8 rk_aiq_user_api2_ae_getLinExpAttr

【Beschreibung】 AE-Belichtungsparameter im linearen Modus abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_getLinExpAttr(const rk_aiq_sys_ctx_t* ctx,
 Uapi_LinExpAttrV2_t* pLinExpAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

6.6.9 rk_aiq_user_api2_ae_setHdrExpAttr

【Beschreibung】 AE-Belichtungsparameter im HDR-Modus einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_setHdrExpAttr(const rk_aiq_sys_ctx_t* ctx, const
 Uapi_HdrExpAttrV2_t hdrExpAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

AE-Belichtungsparameter im HDR-Modus einstellen, darunter beispielsweise manuelles oder automatisches Belichtungsverhältnis und Helligkeitsanpassung Evbias.

 Uapi_HdrExpAttrV2_t HdrExpAttr;
 memset(&HdrExpAttr,0,sizeof(Uapi_HdrExpAttrV2_t));
 ret = rk_aiq_user_api2_ae_getHdrExpAttr(ctx, &HdrExpAttr);
 //set hdr mframe params
 int len = 8;
 float explevel[8] = {0, 0.096, 0.192, 0.384, 0.96, 1.344, 1.92, 3};
 float setpoint[8] = {50, 45, 40, 35, 30, 25, 20, 15};
 HdrExpAttr.HdrAEAttr.MframeCtrl.MExpLevel_len = len;
 HdrExpAttr.HdrAEAttr.MframeCtrl.MSetPoint_len = len;
 HdrExpAttr.HdrAEAttr.MframeCtrl.MExpLevel = explevel;
 HdrExpAttr.HdrAEAttr.MframeCtrl.MSetPoint = setpoint;
 //set ExpRatioType (AUTO/FIX)
 HdrExpAttr.ExpRatioCtrl.ExpRatioType = AECV2_HDR_RATIOTYPE_MODE_AUTO;
 //set Evbias
 HdrExpAttr.Evbias = -100.0f;
 ret = rk_aiq_user_api2_ae_setHdrExpAttr(ctx, HdrExpAttr);

6.6.10 rk_aiq_user_api2_ae_getHdrExpAttr

【Beschreibung】 AE-Belichtungsparameter im HDR-Modus abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_getHdrExpAttr(const rk_aiq_sys_ctx_t* ctx,
 Uapi_HdrExpAttrV2_t* pHdrExpAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

6.6.11 rk_aiq_user_api2_ae_setIrisAttr

【Beschreibung】 Parameter der AE-Blendensteuerung einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_setIrisAttr(const rk_aiq_sys_ctx_t * sys_ctx, const
 Uapi_IrisAttrV2_t irisAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

 Uapi_IrisAttrV2_t irisAttr;
 ret = rk_aiq_user_api2_ae_getIrisAttr(ctx, &irisAttr);
 irisAttr.enable = true; /*run AIris*/
 //set P-iris attributes
 irisAttr.IrisType = IRIS_P_TYPE;
 irisAttr.PIrisAttr.TotalStep = 81;
 irisAttr.PIrisAttr.EffcStep = 44;
 irisAttr.PIrisAttr.ZeroIsMax = true;
 uint16_t StepTable[1024] = {512, 511, 506, 499, 491, 483, 474, 465, 456,
                             446, 437, 427, 417, 408, 398, 388, 378, 368,
                             359, 349, 339, 329, 319, 309, 300, 290, 280,
                             271, 261, 252, 242, 233, 224, 214, 205, 196,
                             187, 178, 170, 161, 153, 144, 136, 128, 120,
                             112, 105, 98, 90, 83, 77, 70, 64, 58,
                             52, 46, 41, 36, 31, 27, 23, 19, 16,
                             13, 10, 8, 6, 4, 3, 1, 1, 0,
                             0, 0, 0, 0, 0, 0, 0, 0, 0};
 memcpy(irisAttr.PIrisAttr.StepTable,StepTable,sizeof(irisAttr.PIrisAttr.StepTable
 ));
 ret = rk_aiq_user_api2_ae_setIrisAttr(ctx, irisAttr);
 //set DC-iris attributes
 irisAttr.IrisType = IRIS_DC_TYPE;
 irisAttr.DCIrisAttr.Kp= 0.5f;
 irisAttr.DCIrisAttr.Ki= 0.2f;
 irisAttr.DCIrisAttr.Kd = 0.3f;
 irisAttr.DCIrisAttr.OpenPwmDuty = 40;
 irisAttr.DCIrisAttr.ClosePwmDuty = 22;
 irisAttr.DCIrisAttr.MinPwmDuty = 0;
 irisAttr.DCIrisAttr.MaxPwmDuty = 100;
 ret = rk_aiq_user_api2_ae_setIrisAttr(ctx, irisAttr);
 //set manual iris with auto ae
 irisAttr.IrisOpType = RK_AIQ_OP_MODE_MANUAL;
 if(irisAttr.IrisType == IRIS_P_TYPE);
     irisAttr.ManualAttr.PIrisGainValue = 512; /*p-iris F#=1.4*/
 if(irisAttr.IrisType == IRIS_DC_TYPE);
     irisAttr.ManualAttr.DCIrisHoldValue = 20; /*dc-iris PwmDuty=20*/
 ret = rk_aiq_user_api2_ae_setIrisAttr(ctx, irisAttr);

6.6.12 rk_aiq_user_api2_ae_getIrisAttr

【Beschreibung】 Parameter der AE-Blendensteuerung abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_getIrisAttr(const rk_aiq_sys_ctx_t * sys_ctx, const
 Uapi_IrisAttrV2_t* irisAttr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

6.6.13 rk_aiq_user_api2_ae_setExpWinAttr

【Beschreibung】 Eigenschaften des AE-Statistikfensters einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_setExpWinAttr(const rk_aiq_sys_ctx_t* sys_ctx, const
 Uapi_ExpWin_t ExpWin);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Die AE-Statistikkoordinaten anhand der Gesichtsposition ändern, um Helligkeitsstatistiken für den Gesichtsbereich zu erfassen.

Hinweis: Beim Einstellen der Statistikkoordinaten muss ExpWin.h_offs+ExpWin.h_size<=pic_width und ExpWin.v_offs+ExpWin.v_size<=pic_height gelten.

 Uapi_ExpWin_t ExpWin;
 //Suppose the sensor resolution is 2688X1520, the lateral offset of the face from the upper left corner of the screen is 100 pixel, the vertical offset is 100 pixel, and the face size is a square with a side length of 100 pixel
 ExpWin.h_offs=100;
 ExpWin.v_offs=100;
 ExpWin.h_size=100;
 ExpWin.v_size=100;
 rk_aiq_user_api2_ae_setExpWinAttr(ctx, ExpWin);

6.6.14 rk_aiq_user_api2_ae_getExpWinAttr

【Beschreibung】 Eigenschaften des AE-Statistikfensters abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_getExpWinAttr(const rk_aiq_sys_ctx_t* sys_ctx,const
 Uapi_ExpWin_t* ExpWin);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

6.6.15 rk_aiq_user_api2_ae_queryExpResInfo

【Beschreibung】 Interne AE-Zustandsinformationen abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_ae_queryExpResInfo(const rk_aiq_sys_ctx_t* ctx,
 Uapi_ExpQueryInfo_t* pExpResInfo);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_ae.h, rk_aiq_uapi2_ae_int.h

Bibliotheksdatei: librkaiq.so

6.7 Datentypen der modulbezogenen APIs

6.7.1 Uapi_ExpSwAttr_t

【Beschreibung】

Parameterstruktur zur Steuerung allgemeiner AE-Funktionen.

【Definition】

 typedef struct Uapi_ExpSwAttrV2_s {
     rk_aiq_uapi_sync_t                 sync;
     uint8_t                            Enable;
     CalibDb_CamRawStatsModeV2_t        RawStatsMode;
     CalibDb_CamHistStatsModeV2_t       HistStatsMode;
     CalibDb_CamYRangeModeV2_t          YRangeMode;
     uint8_t                            AecRunInterval;
     RKAiqOPMode_t                      AecOpType;
     Cam15x15UCharMatrix_t              GridWeights;
     Uapi_AeAttrV2_t                    stAuto;
     Uapi_MeAttrV2_t                    stManual;
     Uapi_ExpSwAttr_AdvancedV2_t        stAdvanced;
 } Uapi_ExpSwAttrV2_t;

【Felder】

Zugehöriger Datentyp

rk_aiq_uapi_sync_t

Uapi_ExpSwAttr_AdvancedV2_t

Uapi_AeAttrV2_t

Uapi_MeAttrV2_t

6.7.1.1 Uapi_ExpSwAttr_AdvancedV2_t

【Beschreibung】

Parameterstrukturen mit Vorrang.

【Definition】

 typedef struct Aec_uapi_advanced_attr_s {
     bool                          enable;
     uint8_t                       GridWeights[15 * 15];
     bool                          SetAeRangeEn;
     Aec_LinAeRange_t              SetLinAeRange;
     Aec_HdrAeRange_t              SetHdrAeRange;
 } Aec_uapi_advanced_attr_t;
 typedef Aec_uapi_advanced_attr_t Uapi_ExpSwAttr_AdvancedV2_t;

【Felder】

【Vorsichtsmaßnahmen】

In Uapi_ExpSwAttrV2_t ist ein Satz AE-Gewichte mit der Größe 15X15 definiert. Der Algorithmus erweitert die Gewichtung entsprechend der tatsächlich von der Hardware konfigurierten Gewichtsanzahl. Für Aufgaben wie die Gesichtsbelichtung kann der in Uapi_ExpSwAttr_AdvancedV2_t definierte Gewichtssatz mit 15X15 Werten verwendet werden. Der Algorithmus verdichtet diese Gewichte entsprechend der tatsächlichen Hardwareanzahl. Um den in Uapi_ExpSwAttr_Advanced_t definierten Gewichtssatz zu verwenden, muss enable auf 1 gesetzt werden.

Beim Einstellen des AE-Parameterbereichs über die API muss SetAeRangeEn auf 1 gesetzt werden; andernfalls gilt standardmäßig der automatische Belichtungsparameterbereich der Abstimmdatei. Je nach Belichtungsmodus erfolgt die Einstellung über SetLinAeRange oder SetHdrAeRange. SetHdrAeRange unterstützt die Bereichseinstellung für jedes Bild. Der endgültig wirksame Belichtungszeit- und Verstärkungsbereich muss zusätzlich in stAuto abgefragt werden; hier steht nur der eingestellte, nicht der endgültig wirksame Bereich.

6.7.1.1.1 Aec_AeRange_t

【Beschreibung】 AE-Parameterbereich definieren.

【Definition】

 typedef struct Aec_AeRange_s {
     float                   Min;
     float                   Max;
 } Aec_AeRange_t;

【Felder】

6.7.1.1.2 Aec_LinAeRange_t

【Beschreibung】 Parameterbereich für den linearen AE-Modus definieren.

【Definition】

 typedef struct Aec_LinAeRange_s {
     Aec_AeRange_t      stExpTimeRange;
     Aec_AeRange_t      stGainRange;
     Aec_AeRange_t      stIspDGainRange;
     Aec_AeRange_t      stPIrisRange;
 } Aec_LinAeRange_t;

【Felder】

【Vorsichtsmaßnahmen】

Wenn Maximum/Minimum jeder Belichtungskomponente den Standardwert 0 besitzt, wird der eingestellte Bereich nicht wirksam. Die tatsächlichen Maxima/Minima werden durch die minimalen und maximalen Knotenwerte des AecRoute-Belichtungszerlegungspfads bestimmt.

Wenn Maximum/Minimum jeder Belichtungskomponente ungleich 0 ist, wird der eingestellte Bereich wirksam. Überschreitet er nicht die Grenzen von Sensor oder ISP, gelten seine Maxima/Minima als tatsächliche Werte; der AecRoute-Belichtungszerlegungspfad wird entsprechend korrigiert und seine maximalen/minimalen Knotenwerte werden auf die eingestellten Komponentenwerte geändert. Werden Sensor- oder ISP-Grenzen überschritten, richten sich die tatsächlichen Maxima/Minima nach den minimalen und maximalen Knotenwerten des AecRoute-Belichtungszerlegungspfads.

6.7.1.1.3 Aec_HdrAeRange_t

【Beschreibung】 Parameterbereich für den AE-HDR-Modus definieren.

【Definition】

 typedef struct Aec_HdrAeRange_s {
     Aec_AeRange_t      stExpTimeRange[3];
     Aec_AeRange_t      stGainRange[3];
     Aec_AeRange_t      stIspDGainRange[3];
     Aec_AeRange_t      stPIrisRange;
 } Aec_HdrAeRange_t;

【Felder】

【Vorsichtsmaßnahmen】

stExpTimeRange, stGainRange und stIspDGainRange sind als Arrays mit 3 Elementen vordefiniert. Im HDR-Modus mit 2 Bildern gelten nur die Elemente 0 und 1 für die Belichtungskomponentenbereiche kurzer bzw. langer Bilder. Im HDR-Modus mit 3 Bildern gelten 0–2 für kurze, mittlere bzw. lange Bilder.

Wenn Maximum/Minimum jeder Belichtungskomponente den Standardwert 0 besitzt, wird der eingestellte Bereich nicht wirksam. Die tatsächlichen Maxima/Minima werden durch die minimalen und maximalen Knotenwerte des vom Algorithmus korrigierten Belichtungszerlegungspfads bestimmt.

Wenn Maximum/Minimum jeder Belichtungskomponente ungleich 0 ist, wird der eingestellte Bereich wirksam. Überschreitet er die Sensor- oder ISP-Grenzen nicht, gelten seine Maxima/Minima als tatsächliche Werte. Der Belichtungszerlegungspfad wird korrigiert und seine maximalen/minimalen Knotenwerte werden auf die eingestellten Komponentenwerte geändert. Werden Sensor- oder ISP-Grenzen

überschritten, richten sich die tatsächlichen Maxima/Minima nach den maximalen und minimalen Knotenwerten des Belichtungszerlegungspfads. Die Plattform 1106 unterstützt derzeit kein isp dgain; stIspDGainRange ist daher vorläufig unwirksam.

6.7.1.2 Uapi_AeAttrV2_t

【Beschreibung】 Eigenschaften der automatischen AE-Belichtung definieren.

【Definition】

 typedef struct Uapi_AeAttrV2_s {
     Uapi_AeSpeedV2_t           stAeSpeed;
     DelayFrmNum
     uint8_t                    BlackDelayFrame;
     uint8_t                    WhiteDelayFrame;
     Auto/Fixed fps
     Uapi_AeFpsAttrV2_t         stFrmRate;
     Uapi_AntiFlickerV2_t       stAntiFlicker;
     auto range
     Aec_LinAeRange_t           LinAeRange;//result LinAerange
     Aec_HdrAeRange_t           HdrAeRange;//result HdrAerange
 } Uapi_AeAttrV2_t;

【Felder】

【Vorsichtsmaßnahmen】

LinAeRange/HdrAeRange enthält den nach interner Prüfung und Korrektur durch den Algorithmus tatsächlich verwendeten Parameterbereich. Überschreitet der per API eingestellte AE-Bereich die Sensorgrenzen, gilt der sensorbegrenzte Bereich. Diese Grenzen finden Sie im AE-Modulparameter sensorinfo des Dokuments Rockchip_Tuning_Guide_ISP30_CN.pdf.

Zum Einstellen des Bereichs der automatischen Belichtungskomponenten verwendet die API die Parameter des oben beschriebenen Uapi_ExpSwAttr_AdvancedV2_t und setzt SetAeRangeEn auf 1. Andernfalls gilt standardmäßig der automatische Belichtungsparameterbereich der Abstimmdatei.

6.7.1.2.1 Uapi_AeSpeedV2_t

【Beschreibung】 Situationsabhängige AE-Anpassungsgeschwindigkeiten definieren.

【Definition】

 typedef struct CalibDb_AeSpeedV2_s {
     float                   DampOver;
     float                   DampUnder;
     float                   DampDark2Bright;
     float                   DampBright2Dark;
 } CalibDb_AeSpeedV2_t;
 typedef CalibDb_AeSpeedV2_t Uapi_AeSpeedV2_t;

【Felder】

6.7.1.2.2 Uapi_AeFpsAttrV2_t

【Beschreibung】 AE-Bildrateneigenschaften definieren.

【Definition】

 typedef struct CalibDb_AeFrmRateAttrV2_s {
     bool             isFpsFix;
     uint8_t          FpsValue;
 } CalibDb_AeFrmRateAttrV2_t;
 typedef CalibDb_AeFrmRateAttrV2_t Uapi_AeFpsAttrV2_t;

【Felder】

6.7.1.2.3 Uapi_AntiFlickerV2_t

【Beschreibung】 Eigenschaften der Flimmerunterdrückung definieren.

【Definition】

 typedef struct CalibDb_AntiFlickerAttrV2_s {
     bool                           enable;
     CalibDb_FlickerFreq_t          Frequency;
     CalibDb_AntiFlickerMode_t      Mode;
 } CalibDb_AntiFlickerAttrV2_t;
 typedef CalibDb_AntiFlickerAttrV2_t Uapi_AntiFlickerV2_t;

【Felder】

【Vorsichtsmaßnahmen】

Zum Ausschalten der Flimmerunterdrückung muss enable auf 0 gesetzt werden; der Algorithmus konfiguriert dann automatisch Frequency=AECV2_FLICKER_FREQUENCY_OFF. Ist enable auf 1 gesetzt und als Frequenz AECV2_FLICKER_FREQUENCY_OFF konfiguriert, ist dieser Frequenzwert ungültig und wird durch den Standardwert AECV2_FLICKER_FREQUENCY_50HZ ersetzt.

Im normalen Modus AECV2_ANTIFLICKER_NORMAL_MODE kann die Belichtungszeit entsprechend der Helligkeit angepasst werden. Die minimale Belichtungszeit ist fest auf 1/120 sec (60Hz) oder 1/100 sec (50Hz) gesetzt und wird nicht durch die minimale Belichtungszeit begrenzt.

Beleuchtete Umgebung: Die Belichtungszeit kann an die Lichtquellenfrequenz angepasst werden, wodurch Bildflimmern vermieden wird.

Sehr helle Umgebung: Je höher die Helligkeit, desto kürzer muss die Belichtungszeit sein. Die minimale Belichtungszeit des normalen Flimmerunterdrückungsmodus kann nicht passend zur Lichtquellenfrequenz eingestellt werden, wodurch Überbelichtung entsteht. AECV2_ANTIFLICKER_AUTO_MODE ist der automatische Modus: Die Belichtungszeit wird helligkeitsabhängig angepasst und kann bis zur minimalen Sensorbelichtungszeit reichen. Der Unterschied zum normalen Modus zeigt sich vor allem bei hoher Helligkeit: Die minimale Sensorbelichtungszeit kann Überbelichtung wirksam unterdrücken, allerdings ist die Flimmerunterdrückung dann unwirksam.

6.7.1.3 Uapi_MeAttrV2_t

【Beschreibung】

Manuelle Belichtungsparametereinstellung, je nach Belichtungsmodus in die beiden Parametersätze LinearAE und HdrAE gegliedert.

【Definition】

 typedef struct Uapi_MeAttrV2_s {
     Uapi_LinMeAttrV2_t     stLinMe;
     Uapi_HdrMeAttrV2_t     stHdrMe;
 } Uapi_MeAttrV2_t;

【Zugehörige Datentypen】

Uapi_LinMeAttrV2_t

Uapi_HdrMeAttrV2_t

6.7.1.3.1 Uapi_LinMeAttrV2_t

【Beschreibung】

Manuelle Belichtungssteuerparameter für LinearAE.

【Definition】

 typedef struct Uapi_LinMeAttrV2_s {
     bool                 ManualTimeEn;
     bool                 ManualGainEn;
     bool                 ManualIspDgainEn;
     float                TimeValue;
     float                GainValue;
     float                IspDGainValue;
 } Uapi_LinMeAttrV2_t;

【Felder】

【Vorsichtsmaßnahmen】

Dieser Modulparameter gilt nur bei AeOptype = MANUAL. Sind ManualTimeEn, ManualGainEn und ManualIspDgainEn alle 1, handelt es sich um manuellen Modus. Sobald einer dieser drei Parameter nicht aktiviert ist, liegt halbautomatischer Modus vor. Sind alle vier oben genannten Werte 0, entspricht dies Automatikmodus und das System meldet einen Fehlerhinweis (die Quelle schreibt hier trotz der drei genannten Parameter „vier“).

Im manuellen/halbmanuellen Modus werden Belichtungszeit und Verstärkung durch die maximalen/minimalen Werte des Automatikmodus begrenzt. Bei Überschreitung gelten stattdessen die jeweiligen Maxima/Minima des Automatikmodus.

RK356X unterstützt keine digitale ISP-Verstärkung; ManualIspDgainEn und IspDGainValue sind daher unwirksam.

6.7.1.3.2 Uapi_HdrMeAttrV2_t

【Beschreibung】

Manuelle Belichtungssteuerparameter für HdrAE.

【Definition】

 typedef struct Uapi_HdrMeAttrV2_s {
     bool                    ManualTimeEn;
     bool                    ManualGainEn;
     bool                    ManualIspDgainEn;
     Cam3x1FloatMatrix_t     TimeValue;
     Cam3x1FloatMatrix_t     GainValue;
     Cam3x1FloatMatrix_t     IspDGainValue;
 } Uapi_HdrMeAttrV2_t;

【Felder】

Die Variablen haben dieselbe Bedeutung wie in Uapi_LinMeAttrV2_t.

【Vorsichtsmaßnahmen】

TimeValue/GainValue/IspDGainValue sind Arrays mit 3 Elementen. Im HDR-Modus mit 2 Bildern gelten die Elemente [0-1] für kurze bzw. lange Bilder. Im HDR-Modus mit 3 Bildern gelten [0-2] für kurze, mittlere bzw. lange Bilder.

Im manuellen/halbmanuellen Modus werden Belichtungszeit und Verstärkung durch die maximalen/minimalen Werte des Automatikmodus begrenzt. Bei Überschreitung gelten stattdessen die jeweiligen Maxima/Minima des Automatikmodus.

RK356X unterstützt derzeit keine digitale ISP-Verstärkung; ManualIspDgainEn und IspDGainValue sind daher unwirksam.

6.7.2 Uapi_LinAeRouteAttr_t

【Beschreibung】 Eigenschaften des linearen AE-Belichtungszerlegungspfads definieren.

【Definition】

 typedef struct CalibDb_LinAeRoute_AttrV2_s {
     float* TimeDot;
     int TimeDot_len;
     float* GainDot;
     int GainDot_len;
     float* IspDGainDot;
     int IspDGainDot_len;
     int* PIrisDot;
     int PIrisDot_len;
 } CalibDb_LinAeRoute_AttrV2_t;
 typedef struct Uapi_LinAeRouteAttr_s {
   rk_aiq_uapi_sync_t            sync;
   CalibDb_LinAeRoute_AttrV2_t   Params;
 } Uapi_LinAeRouteAttr_t;

【Felder】

【Vorsichtsmaßnahmen】

Die Anzahl der Knoten der Belichtungszerlegungskurve ist nicht begrenzt; empfohlen werden jedoch mindestens 6.

Die Belichtung eines Knotens ist das Produkt seiner Komponenten wie Belichtungszeit, Sensorverstärkung, digitaler ISP-Verstärkung und blendenäquivalenter Verstärkung. Sie muss monoton steigen, d. h. ein späterer Knoten muss stärker belichtet sein als der vorherige. Der erste Knoten hat die geringste und der zweite Knoten die größte Belichtung (so formuliert es die Quelle).

Die Belichtungszeitkomponente eines Knotens wird in Sekunden angegeben; als Minimum ist 0 erlaubt. Der tatsächliche minimale Belichtungszeitcode wird intern anhand der Sensorgrenze korrigiert.

Die Blendenkomponente unterstützt nur P-Iris, nicht DC-Iris. Die äquivalente P-Iris-Verstärkung gilt nur bei aktivierter automatischer Airis-Blendenfunktion; andernfalls bleibt die Blende standardmäßig auf ihrer Anfangsgröße fixiert. Die Berechnung der äquivalenten P-Iris-Verstärkung ist im Modul AecIrisCtrl beschrieben.

Die eingestellten Knoten des Belichtungszerlegungspfads bilden nicht den endgültigen Pfad. Die tatsächlichen maximalen/minimalen Werte jeder endgültigen Belichtungskomponente ergeben sich aus der Kombination der Zerlegungsknoten und der manuell konfigurierten Komponentenmaxima/-minima. Zunächst erfolgt eine erste Korrektur der maximalen/minimalen Knotenwerte:

Überschreiten diese Werte die SENSOR- oder ISP-Grenzen nicht, bleiben sie unverändert; andernfalls werden sie auf die Sensor- oder ISP-Grenzen begrenzt. Sind die manuell konfigurierten Komponentenmaxima/-minima 0, gilt der nach der ersten Korrektur erhaltene Pfad. Sind sie ungleich 0 und liegen innerhalb der SENSOR- oder ISP-Grenzen, erfolgt eine zweite Korrektur; dann richten sich die Knotenmaxima/-minima nach dem manuell eingestellten Bereich. Überschreitet dieser Bereich die Sensor- oder ISP-Grenzen, gelten die Ergebnisse der ersten Korrektur. Wenn die Belichtung benachbarter Knoten steigt, sollte nur eine Komponente steigen und die übrigen unverändert bleiben. Die steigende Komponente bestimmt die Verteilungsstrategie dieses Pfadsegments. Steigt beispielsweise die Verstärkung bei konstanten übrigen Komponenten, hat dieses Segment Verstärkungspriorität.

RK356X unterstützt derzeit keine digitale ISP-Verstärkung; IspgainDot ist daher unwirksam.

6.7.3 Uapi_HdrAeRouteAttr_t

【Beschreibung】 Eigenschaften des AE-HDR-Belichtungszerlegungspfads definieren.

【Definition】

 typedef struct CalibDb_HdrAeRoute_AttrV2_s {
     float* Frm0TimeDot;
     int Frm0TimeDot_len;
     float* Frm0GainDot;
     int Frm0GainDot_len;
     float* Frm0IspDGainDot;
     int Frm0IspDGainDot_len;
     float* Frm1TimeDot;
     int Frm1TimeDot_len;
     float* Frm1GainDot;
     int Frm1GainDot_len;
     float* Frm1IspDGainDot;
     int Frm1IspDGainDot_len;
     float* Frm2TimeDot;
     int Frm2TimeDot_len;
     float* Frm2GainDot;
     int Frm2GainDot_len;
     float* Frm2IspDGainDot;
     int Frm2IspDGainDot_len;
     int* PIrisDot;
     int PIrisDot_len;
 } CalibDb_HdrAeRoute_AttV2r_t;
 typedef struct Uapi_HdrAeRouteAttr_s {
   rk_aiq_uapi_sync_t            sync;
   CalibDb_HdrAeRoute_AttrV2_t   Params;
 } Uapi_HdrAeRouteAttr_t;

【Felder】

【Vorsichtsmaßnahmen】

Die Anzahl der Knoten der Belichtungszerlegungskurve ist unbegrenzt. Mindestens 6 Knoten werden empfohlen, um eine gleichmäßige Belichtungszerlegung zu erzielen.

Bei HDR mit 2 Bildern müssen nur Frm0/1TimeDot, Frm0/1GainDot und Frm0/1IspDGainDot für das kurze bzw. lange Bild eingestellt werden. Bei HDR mit 3 Bildern sind Frm0/1/2TimeDot, Frm0/1/2GainDot und Frm0/1/2IspDGainDot für kurze, mittlere und lange Bilder einzustellen. Verteilen Sie die Sensorbelichtungszeiten im HDR-Modus sinnvoll: Die Summe aller Bildbelichtungszeiten ** darf die durch die Bildrate erlaubte maximale Belichtungszeit nicht überschreiten**!

Die Belichtung eines Knotens ist das Produkt seiner Komponenten wie Belichtungszeit, Sensorverstärkung, digitaler ISP-Verstärkung und blendenäquivalenter Verstärkung. Sie muss monoton steigen, d. h. ein späterer Knoten muss stärker belichtet sein als der vorherige. Der erste Knoten hat die geringste und der zweite Knoten die größte Belichtung (so formuliert es die Quelle).

Die Belichtungszeitkomponente eines Knotens wird in Sekunden angegeben; als Minimum ist 0 erlaubt. Der tatsächliche minimale Belichtungszeitcode wird intern anhand der Sensorgrenze korrigiert.

Die Blendenkomponente unterstützt nur P-Iris, nicht DC-Iris. Die äquivalente P-Iris-Verstärkung gilt nur bei aktivierter automatischer Airis-Blendenfunktion; andernfalls bleibt die Blende standardmäßig auf ihrer Anfangsgröße fixiert. Die Berechnung der äquivalenten P-Iris-Verstärkung ist im Modul AecIrisCtrl beschrieben.

Die eingestellten Knoten des Belichtungszerlegungspfads bilden nicht den endgültigen Pfad. Die tatsächlichen maximalen/minimalen Werte jeder endgültigen Belichtungskomponente ergeben sich aus der Kombination der Zerlegungsknoten und der manuell konfigurierten Komponentenmaxima/-minima. Zunächst werden die Knotenmaxima/-minima korrigiert: Liegen sie innerhalb der SENSOR- oder ISP-Grenzen, bleiben sie unverändert; andernfalls gelten diese Grenzen. Sind die manuell konfigurierten Komponentenmaxima/-minima 0, gilt der Pfad nach dieser ersten Korrektur. Sind sie ungleich 0 und überschreiten die SENSOR- oder ISP-Grenzen nicht, erfolgt eine

zweite Korrektur, bei der die Knotenmaxima/-minima dem manuell eingestellten Bereich entsprechen. Überschreitet der eingestellte Komponentenbereich die Sensor- oder ISP-Grenzen, gelten die Ergebnisse der ersten Korrektur. Bei steigender Belichtung benachbarter Knoten sollte nur eine Komponente steigen und die übrigen konstant bleiben. Die steigende Komponente bestimmt die Verteilungsstrategie dieses Pfadsegments. Steigt beispielsweise die Verstärkung bei konstanten übrigen Komponenten, hat dieses Segment Verstärkungspriorität.

356X unterstützt derzeit keine digitale ISP-Verstärkung; Frm0/1/2ispDGainDot sind daher unwirksam.

6.7.4 Uapi_LinExpAttrV2_t

【Beschreibung】

Abstimmparameter der linearen AE-Belichtung definieren.

【Definition】

 typedef struct CalibDb_LinearAE_AttrV2_s {
     uint8_t RawStatsEn;
     float ToleranceIn;
     float ToleranceOut;
     float Evbias;
     CalibDb_AeStrategyModeV2_t      StrategyMode;
     CalibDb_LinExpInitExpV2_t       InitExp;
     CalibDb_LinAeRoute_AttrV2_t     Route;
     CalibDb_AecDynamicSetpointV2_t  DySetpoint;
     CalibDb_AecBacklightV2_t        BackLightCtrl;
     CalibDb_AecOverExpCtrlV2_t OverExpCtrl;
 } CalibDb_LinearAE_AttrV2_t;
 typedef struct Uapi_LinExpAttrV2_s {
   rk_aiq_uapi_sync_t            sync;
   CalibDb_LinearAE_AttrV2_t     Params;
 } Uapi_LinExpAttrV2_t;

【Felder】

【Vorsichtsmaßnahmen】

EvBias dient in besonderen Szenarien zur Feinabstimmung der festen/dynamischen Helligkeitssollwerte (SetPoint/IRSetPoint). Der tatsächlich wirksame Helligkeitssollwert ist (SetPoint)*[1+abs(EvBias)/100]^[EvBias/abs(EvBias)]. Bei EvBias=100 beträgt er das Doppelte des Standardparameters; bei EvBias=-100 die Hälfte.

Die AE-Bildhelligkeitstoleranz heißt Tolerance. Nach AE-Konvergenz sollte die Helligkeit B im Bereich [tatsächlich wirksamer Helligkeitssollwert X(1-Tolerance/100), tatsächlich wirksamer Helligkeitssollwert X(1+Tolerance/100)] liegen. Große ToleranceIn/Out-Werte beeinflussen sowohl die AE-Reaktionsgeschwindigkeit als auch die Wirkung von EvBias. Ist die Schrittweite der EvBias-Anpassung kleiner als ToleranceIn/Out, kann die Helligkeitsanpassung unwirksam bleiben.

StrategyMode ist derzeit unwirksam.

【Zugehörige Datentypen】

CalibDb_AecDynamicSetpointV2_t

CalibDb_AecBacklightV2_t

CalibDb_AecOverExpCtrlV2_t

6.7.4.1 CalibDb_AecDynamicSetpointV2_t

【Beschreibung】 Dynamische AE-Sollwerte definieren.

【Definition】

 typedef struct CalibDb_AecDynamicSetpointV2_s {
     float* ExpLevel;
     int ExpLevel_len;
     float* DySetpoint;
     int DySetpoint_len;
 } CalibDb_AecDynamicSetpointV2_t;

【Felder】

6.7.5 Uapi_HdrExpAttrV2_t

【Beschreibung】 Abstimmparameter der AE-HDR-Belichtung definieren.

【Definition】

 typedef struct CalibDb_HdrAE_AttrV2_s {
     float ToleranceIn;
     float ToleranceOut;
     float Evbias;
     CalibDb_AeStrategyModeV2_t StrategyMode;
     float LumaDistTh; //used for area-growing
     CalibDb_HdrExpInitExpV2_t InitExp;
     CalibDb_HdrAeRoute_AttrV2_t Route;
     CalibDb_ExpRatioCtrlV2_t ExpRatioCtrl;
     CalibDb_LongFrmCtrlV2_t LongFrmMode;
     CalibDb_LfrmCtrlV2_t LframeCtrl;
     CalibDb_MfrmCtrlV2_t MframeCtrl;
     CalibDb_SfrmCtrlV2_t SframeCtrl;
 } CalibDb_HdrAE_AttrV2_t;
 typedef struct Uapi_HdrExpAttrV2_s {
   rk_aiq_uapi_sync_t            sync;
   CalibDb_HdrAE_AttrV2_t        Params;
 } Uapi_HdrExpAttrV2_t;

【Felder】

【Zugehörige Datentypen】

CalibDb_LFrameCtrlV2_t

CalibDb_MFrameCtrlV2_t

CalibDb_SFrameCtrlV2_t

6.7.6 Uapi_IrisAttrV2_t

【Beschreibung】

Blendensteuerparameter.

【Definition】

 typedef struct CalibDb_AecIrisCtrlV2_s {
     uint8_t Enable;
     CalibDb_IrisTypeV2_t IrisType;
     RKAiqOPMode_t IrisOpType;
     CalibDb_MIris_AttrV2_t ManualAttr;
     CalibDb_PIris_AttrV2_t PIrisAttr;
     CalibDb_DCIris_AttrV2_t DCIrisAttr;
 } CalibDb_AecIrisCtrlV2_t;
 typedef struct Uapi_IrisAttrV2_s {
   rk_aiq_uapi_sync_t            sync;
   CalibDb_AecIrisCtrlV2_t       Params;
 } Uapi_IrisAttrV2_t;

【Felder】

6.7.6.1 CalibDb_MIris_AttrV2_t

【Beschreibung】

Manuelle Blendenparameter.

【Definition】

 typedef struct CalibDb_MIris_AttrV2_s {
     int PIrisGainValue;
     int DCIrisHoldValue;
 } CalibDb_MIris_AttrV2_t;

【Felder】

【Vorsichtsmaßnahmen】

IrisOpType = RK_AIQ_OP_MODE_MANUAL aktiviert die manuelle Blende. Bei P-Blende ist nur PirisGainValue wirksam; bei DC-Blende nur DCIrisHoldValue.

DCIrisHoldValue setzt im manuellen Modus direkt das PWM-Tastverhältnis des Motors, Wertebereich [0,100]. Liegt der eingestellte HoldValue im Bereich von ClosePwmDuty bis OpenPwmDuty in AecIrisCtrl, bleibt die DC-Blende auf ihrer aktuellen Größe. Ein Wert über OpenPwmDuty öffnet die Blende; je größer der Wert, desto schneller die Öffnung. Ein Wert unter ClosePwmDuty schließt die Blende; je kleiner der Wert, desto schneller das Schließen.

6.7.6.2 CalibDb_PIris_AttrV2_t

【Beschreibung】

Eigenschaftsparameter der P-Blende.

【Definition】

 #define AEC_PIRIS_STAP_TABLE_MAX (1024)
 typedef struct CalibDb_PIris_AttrV2_s {
     uint16_t              TotalStep;
     uint16_t              EffcStep;
     bool                  ZeroIsMax;
     uint16_t              StepTable[AEC_PIRIS_STAP_TABLE_MAX];
 } CalibDb_PIris_AttrV2_t;

【Felder】

6.7.6.3 CalibDb_DCIris_AttrV2_t

【Beschreibung】

Eigenschaften der DC-Blende.

【Definition】

 typedef struct CalibDb_DCIris_AttrV2_s {
     float       Kp;
     float       Ki;
     float       Kd;
     int         MinPwmDuty;
     int         MaxPwmDuty;
     int         OpenPwmDuty;
     int         ClosePwmDuty;
 } CalibDb_DCIris_AttrV2_t;

【Felder】

【Vorsichtsmaßnahmen】

Wenn die automatische Blendenfunktion deaktiviert ist, wird eine DC-Iris-Blende standardmäßig vollständig geöffnet. Bei P-Iris wird standardmäßig die Schrittmotorposition für maximale Öffnung angefahren. Zur Änderung dieser Positionen können InitPIrisGainValue und InitDCIrisDutyValue im Modul AecInitValue angepasst werden.

Der grundlegende Steuerablauf des automatischen Blendenalgorithmus Airis lautet:

Bei DC-Iris-Objektiven steuert Airis die Blendenöffnung anhand der Abweichung zwischen aktueller Helligkeit und Helligkeitssollwert. Wenn die Belichtung ihr Minimum erreicht und die aktuelle Helligkeit den Sollwerttoleranzbereich überschreitet, wird die AE-Regelung verlassen. Belichtungszeit und Verstärkung werden fixiert und AIRIS übernimmt die Regelung. Ist die aktuelle Bildhelligkeit stabil und das PWM-Tastverhältnis

der DC-Iris größer als OpenPwmDuty, wird die maximale Blendenöffnung als erreicht betrachtet. Airis beendet die Blendenregelung und übergibt die Steuerung an AE.

Bei P-Iris-Objektiven erfolgt die Blendensteuerung über AecRoute. Die Blendenöffnung wird in eine äquivalente Verstärkung umgerechnet und in die Berechnung der Belichtungszerlegung einbezogen.

Die Zuordnungstabelle StepTable zwischen P-Iris-Schrittmotorposition und blendenäquivalenter Verstärkung wird gewöhnlich aus der vom Objektivhersteller gelieferten Zuordnung zwischen Motorposition und Blendenöffnung erstellt. Da das AE-Modul AecRoute die Öffnung in äquivalente Verstärkung umrechnet, muss die P-Iris-Steuerung gut linear sein. Die äquivalente Verstärkung liegt im Bereich [1,1024]: F1.0 entspricht 1024, F1.4 entspricht 512 und entsprechend fortgesetzt F32.0 dem Wert 1. Rechnen Sie zur Tabellenerstellung die Öffnung jeder Motorposition in äquivalente Verstärkung um und tragen Sie sie in StepTable in aufsteigender Reihenfolge der Motorpositionen ein (step0, step1… stepN).

TotalStep bezeichnet die gesamte Schrittzahl des P-Iris-Schrittmotors und hängt vom Objektiv ab. EffcStep bezeichnet die nutzbare Schrittzahl und ist gewöhnlich kleiner als TotalStep. Nahe der vollständig geschlossenen Position ist der Fehler der entsprechenden äquivalenten Verstärkung groß und bei der Blendenregelung können leicht Schwingungen entstehen. Daher werden solche Positionen gewöhnlich nicht verwendet.

Tabelle 4-1 ordnet P-Iris-Schrittmotorposition, Blendenfläche und äquivalente Verstärkung einander zu und dient als Beispiel für StepTable. Die Zuordnung zwischen Motorschritt und Fläche in Spalten 1–2 und 4–5 stammt von einem Objektivhersteller. Das Objektiv hat insgesamt 81 Motorschritte; step0 entspricht der größten Öffnung mit einer nominalen maximalen Blende von 1.4. Diese entspricht einer äquivalenten Verstärkung von 512, somit beträgt sie bei Schritt 0 ebenfalls 512. Beispiel Schritt 3: Die Fläche beträgt 195.869; daraus ergibt sich die äquivalente Verstärkung = 512* (195.869/201.062)=499(gerundet). Entsprechend lassen sich die Werte anderer Motorpositionen berechnen. Aus Tabelle 1-1 (Verweis der Quelle) ist ersichtlich, dass nahe der geschlossenen Position die Fläche sehr klein ist und gegenüber der größten Fläche um Tausende Faktoren abweichen kann. Der Fehler der äquivalenten Verstärkung ist dann groß. Solche Positionen sollten zur Vermeidung fehlerbedingter Belichtungsschwingungen nicht verwendet werden. Die äquivalente Verstärkung jeder Motorposition wird in aufsteigender Reihenfolge der Positionen (step0, step1… stepN) in StepTable eingetragen.

OpenPwmDuty und ClosePwmDuty der DC-Iris müssen gemessen werden und hängen vom Objektiv ab. Bei einigen Objektiven öffnet die Blende, wenn das PWM-Tastverhältnis über OpenPwmDuty liegt; liegt es darunter, schließt sie (die Quelle nennt hier ebenfalls OpenPwmDuty). Im Bereich größer oder gleich ClosePwmDuty und kleiner oder gleich OpenPwmDuty bleibt sie stabil; die Werte dieses Bereichs heißen HoldValue. Andere Objektive besitzen nur eine Öffnungs-/Schließschwelle: Oberhalb öffnet die Blende, unterhalb schließt sie und genau auf der Schwelle bleibt sie stabil. Dieser Wert ist HoldValue; in diesem Fall kann ClosePwmDuty = OpenPwmDuty = HoldValue gesetzt werden.

Die manuelle Blendenparametereinstellung entspricht dem manuellen Belichtungsmodus. Setzen Sie für manuelle Blendensteuerung AecOpType auf manuellen Modus und aktivieren Sie ManualIrisEn in AecManualCtrl. Wenn IrisType P-iris ist, gilt nur PirisGainValue; wenn IrisType P-iris ist, gilt nur DCIrisValue. Die Quelle nennt in beiden Fällen P-iris; dieser Widerspruch bleibt erhalten.

Tabelle 4-1 Zuordnung von P-Iris-Schrittmotorposition, Blendenfläche und äquivalenter Verstärkung

6.7.7 Uapi_ExpWin_t

【Beschreibung】 Eigenschaftsparameter des AE-Statistikfensters definieren.

【Definition】

 typedef struct window {
     uint16_t h_offs;
     uint16_t v_offs;
     uint16_t h_size;
     uint16_t v_size;
 } window_t;
 typedef struct Uapi_ExpWin_s {
   rk_aiq_uapi_sync_t            sync;
   window                        Params;
 } Uapi_ExpWin_t;

【Felder】

6.7.8 Uapi_ExpQueryInfo_t

【Beschreibung】 AE-Belichtungsparameterabfragen definieren.

【Definition】

 typedef struct Uapi_ExpQueryInfo_s {
     bool              IsConverged;
     bool              IsExpMax;
     float             LumaDeviation;
     float             HdrLumaDeviation[3];
     float             MeanLuma;
     float             HdrMeanLuma[3];
     float             GlobalEnvLux;
     float             BlockEnvLux[ISP2_RAWAE_WINNUM_MAX];
     RKAiqAecExpInfo_t CurExpInfo;
     unsigned short    Piris;
     float             LinePeriodsPerField;
     float             PixelPeriodsPerLine;
     float             PixelClockFreqMHZ;
 } Uapi_ExpQueryInfo_t;

【Felder】

6.8 Häufige Probleme und Debugging-Methoden

Bei Bildhelligkeitsflimmern, Überschwingen oder unerwarteter Helligkeit empfiehlt es sich, das AE-LOG der problematischen Szene zur Analyse zu erfassen. Dies hilft, die Ursache schneller zu finden und effizienter zu arbeiten.

6.8.1 Synchroner Test von Belichtung und Statistik

Vor der Kalibrierung des ISP-Moduls müssen Treiber- oder Abstimmverantwortliche den Parameter SensorInfo in der IQ-XML-Abstimmdatei ausfüllen. Dieses Modul betrifft Belichtungsparametereinstellungen; falsche Werte können Belichtungsfehler, Flimmern usw. verursachen. Nach der Konfiguration von sensorinfo sollte SyncTest für einen Selbsttest aktiviert werden. Die Bedeutung der SensorInfo-Parameter beschreibt Rockchip_Tuning_Guide_ISP30.

SyncTest stellt zyklisch N Gruppen unterschiedlicher Belichtungswerte ein, um zu prüfen, ob Sensorbelichtungszeit, Sensorverstärkung und die Bildanzahl bis zum Wirksamwerden einer DCG-Umschaltung korrekt sind. Außerdem kann damit die Belichtungslinearität getestet werden, um Umrechnungsformeln und zugehörige Parameter zwischen Registerwerten und Belichtungszeit/-verstärkung zu bestätigen.

Die SyncTest-Funktionsparameter werden nachfolgend beschrieben:

【Beschreibung】

Der synchrone Test von Belichtung und Statistik stellt zyklisch N Gruppen unterschiedlicher Belichtungswerte mit einem vorgegebenen Bildintervall ein. Damit wird geprüft und abgestimmt, ob die Bildanzahl bis zum Wirksamwerden von Belichtungskomponenten (Zeit und Verstärkung) sowie die Sensorbelichtungsparametereinstellungen korrekt sind.

【Felder】

AlterExp

Je nach Modus werden zwei Parametersätze unterschieden: LinearAE und HdrAE.

Bei korrekten Parametern ergibt sich beispielsweise folgendes LOG; es zeigt nur die Schlüsselinformationen. Die rote Umrahmung markiert die Belichtungsumschaltung. Die sichtbare Helligkeit ändert sich nicht und passt zum Belichtungswert; es gibt keine verzögerte oder vorgezogene Linearitätsabweichung. Damit lässt sich grundsätzlich von korrekt gesetzten sensorinfo-Parametern ausgehen.

6.8.2 Flimmern bei Belichtungsänderungen

Flimmern bei Belichtungsänderungen kann mehrere Ursachen haben:

(1) Falsche Bildanzahl bis zum Wirksamwerden von gain und time im Modul CISExpUpdate. Typische LOG-Beispiele folgen; pro Bild werden nur die Schlüsselzeilen gezeigt:

Die rote Umrahmung markiert die Helligkeitsfehler. Bei steigender oder fallender Belichtung entwickelt sich die entsprechende Helligkeit entgegengesetzt. Der abrupte Helligkeitswechsel tritt im zweiten Bild nach einer Änderung sowohl der Belichtungszeit als auch der Verstärkung auf. Die Helligkeitsentwicklung folgt der Belichtungszeit. Daraus lässt sich schließen, dass die Bildanzahl bis zum Wirksamwerden von gain und time falsch ist: Zeit und Verstärkung werden nicht gleichzeitig wirksam, sodass Helligkeit und Belichtung nicht zusammenpassen. Ändern Sie zur Behebung die entsprechenden Bildanzahlen. Das Problem lässt sich mit AE

syncTest nachstellen: Zwei Belichtungssätze mit unterschiedlicher Zeit und Verstärkung abwechselnd schalten und anhand des LOG prüfen, ob das Problem auftritt.

(2) Treiberfehler verursachen nicht konvergierende Helligkeitsschwingungen, häufig bei hellen Szenen. Typische LOG-Beispiele folgen; gezeigt werden nur die Schlüsselzeilen jedes Bildes.

Wie die Abbildung zeigt, schwankt die Belichtung zwischen 59ms und 44ms. Das Verhältnis der zugehörigen mittleren Helligkeiten weicht stark vom Verhältnis der Belichtungszeiten ab; es besteht ein Linearitätsproblem. Prüfen Sie zuerst den Sensortreiber und geben Sie den Belichtungsregisterwert aus, um seine Übereinstimmung mit der protokollierten Belichtung zu prüfen. Das Problem lässt sich mit AE syncTest nachstellen: Mehrere Belichtungssätze einschließlich des problematischen abwechselnd schalten und im LOG prüfen, ob die Helligkeitsänderung jedes Bildes linear zur Belichtung verläuft.

(3) Flimmern durch nachgelagerte AE-Module. Typische LOG-Beispiele folgen; gezeigt werden nur die Schlüsselzeilen jedes Bildes:

Im LOG ist zu erkennen, dass während des Rückgangs von SMeanLuma und MMeanLuma links die Ausgangshelligkeit des TmoMeanluma-Moduls schwankt. In diesem Fall muss das TMO-Modul abgestimmt werden.

7. AWB

7.1 Überblick

Das AWB-Modul verändert die Farbkanalverstärkung des Aufnahmegeräts, um Farbabweichungen durch die Farbtemperatur der Umgebung sowie Abweichungen der geräteeigenen Farbkanalverstärkung gemeinsam auszugleichen. Dadurch soll das aufgenommene Bild die tatsächlichen Farben des Objekts korrekt wiedergeben.

7.2 Wichtige Begriffe

Farbtemperatur: Sie wird anhand eines idealen schwarzen Körpers definiert. Stimmt die Strahlung einer Lichtquelle im sichtbaren Bereich genau mit der eines idealen schwarzen Körpers überein, heißt dessen Temperatur Farbtemperatur der Lichtquelle.

Weißabgleich: Bei Lichtquellen unterschiedlicher Farbtemperatur kann die Sensorantwort auf Weiß bläulich oder rötlich ausfallen. Der Weißabgleichsalgorithmus passt die Intensitäten der drei Farbkanäle R, G und B so an, dass Weiß naturgetreu erscheint.

7.3 Funktionsbeschreibung

Das AWB-Modul besteht aus zwei Teilen: WB-Informationsstatistik und AWB-Steuerstrategiealgorithmus.

7.4 Referenz der funktionsbezogenen APIs

7.4.1 rk_aiq_uapi2_setWBMode

【Beschreibung】 Betriebsart des Weißabgleichs einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setWBMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode);

【Parameter】

【Rückgabewert】

【Hinweis】

Im manuellen Modus wird der Weißabgleichsverstärkungswert durch den aktuellen manuellen Weißabgleichsparameter bestimmt. Um gleichzeitig in den manuellen Modus zu wechseln und einen bestimmten Verstärkungswert einzustellen, kann rk_aiq_uapi2_setMWBGain verwendet werden.

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.2 rk_aiq_uapi2_getWBMode

【Beschreibung】 Betriebsart des Weißabgleichs abrufen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getWBMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.3 rk_aiq_uapi2_lockAWB

【Beschreibung】 Aktuelle Weißabgleichsparameter sperren.

【Syntax】

 XCamReturn rk_aiq_uapi2_lockAWB(const rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.4 rk_aiq_uapi2_unlockAWB

【Beschreibung】 Gesperrte Weißabgleichsparameter wieder freigeben.

【Syntax】

 XCamReturn rk_aiq_uapi2_unlockAWB(const rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.5 rk_aiq_uapi2_setMWBScene

【Beschreibung】 Weißabgleichsszene einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setMWBScene(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_wb_scene_t scene);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.6 rk_aiq_uapi2_getMWBScene

【Beschreibung】 Weißabgleichsszene abrufen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getMWBScene(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_wb_scene_t *scene);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.7 rk_aiq_uapi2_setMWBGain

【Beschreibung】 Manuellen Weißabgleichsverstärkungsfaktor einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setMWBGain(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_gain_t
 *gain);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.8 rk_aiq_uapi2_getWBGain

【Beschreibung】 Weißabgleichsverstärkungsfaktor abrufen. Diese Funktion gilt sowohl für manuellen als auch automatischen Weißabgleich.

【Syntax】

 XCamReturn rk_aiq_uapi2_getWBGain(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_gain_t
 *gain);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.9 rk_aiq_uapi2_setMWBCT

【Beschreibung】 Farbtemperaturparameter des manuellen Weißabgleichs einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setMWBCT(const rk_aiq_sys_ctx_t* ctx, unsigned int ct);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.10 rk_aiq_uapi2_getWBCT

【Beschreibung】 Farbtemperatur des Weißabgleichs abrufen. Diese Funktion gilt für automatischen und manuellen Betrieb.

【Syntax】

 XCamReturn rk_aiq_uapi2_getWBCT(const rk_aiq_sys_ctx_t* ctx, unsigned int *ct);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.11 rk_aiq_uapi2_setAwbGainOffsetAttrib

【Beschreibung】 Offset der automatischen Weißabgleichsverstärkung einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setAwbGainOffsetAttrib(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_uapiV2_wb_awb_wbGainOffset_t attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.12 rk_aiq_uapi2_getAwbGainOffsetAttrib

【Beschreibung】 Offset der automatischen Weißabgleichsverstärkung abrufen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getAwbGainOffsetAttrib(const rk_aiq_sys_ctx_t* ctx,
 CalibDbV2_Awb_gain_offset_cfg_t *attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.13 rk_aiq_uapi2_setAwbGainAdjustAttrib

【Beschreibung】 Farbtonanpassungsparameter im automatischen Weißabgleichsmodus einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setAwbGainAdjustAttrib(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.14 rk_aiq_uapi2_getAwbGainAdjustAttrib

【Beschreibung】 Farbtonanpassungsparameter im automatischen Weißabgleichsmodus abrufen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getAwbGainAdjustAttrib(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t *attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.15 rk_aiq_uapi2_setAwbV30AllAttrib

【Beschreibung】 Alle von der Weißabgleichs-API unterstützten Parameter einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setAwbV30AllAttrib(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_uapiV2_wbV30_attrib_t attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.4.16 rk_aiq_uapi2_getAwbV30AllAttrib

【Beschreibung】 Alle von der Weißabgleichs-API unterstützten Parameter abrufen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getAwbV30AllAttrib(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_uapiV2_wbV30_attrib_t *attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.5 Datentypen der funktionsbezogenen APIs

7.5.1 rk_aiq_wb_op_mode_t

【Beschreibung】 Weißabgleichsbetriebsart definieren.

【Definition】

 typedef enum rk_aiq_wb_op_mode_s {
     RK_AIQ_WB_MODE_INVALID        = 0,
     RK_AIQ_WB_MODE_MANUAL         = 1,
     RK_AIQ_WB_MODE_AUTO           = 2,
     RK_AIQ_WB_MODE_MAX
 } rk_aiq_wb_op_mode_t;

【Felder】

7.5.2 rk_aiq_wb_mwb_mode_t

【Beschreibung】 Typ des manuellen Weißabgleichsmodus definieren.

【Definition】

 typedef enum rk_aiq_wb_mwb_mode_e {
     RK_AIQ_MWB_MODE_INVAILD              = 0,
     RK_AIQ_MWB_MODE_CCT                  = 1,
     RK_AIQ_MWB_MODE_WBGAIN               = 2,
     RK_AIQ_MWB_MODE_SCENE                = 3,
 } rk_aiq_wb_mwb_mode_t;

【Felder】

7.5.3 rk_aiq_wb_gain_t

【Beschreibung】 Weißabgleichsverstärkungsparameter definieren.

【Definition】

 typedef struct rk_aiq_wb_gain_s {
     float rgain;
     float grgain;
     float gbgain;
     float bgain;
 } rk_aiq_wb_gain_t;

【Felder】

7.5.4 rk_aiq_wb_scene_t

【Beschreibung】 Weißabgleichsverstärkungsparameter definieren.

【Definition】

 typedef enum rk_aiq_wb_scene_e {
     RK_AIQ_WBCT_INCANDESCENT = 0,
     RK_AIQ_WBCT_FLUORESCENT,
     RK_AIQ_WBCT_WARM_FLUORESCENT,
     RK_AIQ_WBCT_DAYLIGHT,
     RK_AIQ_WBCT_CLOUDY_DAYLIGHT,
     RK_AIQ_WBCT_TWILIGHT,
     RK_AIQ_WBCT_SHADE
 } rk_aiq_wb_scene_t;

【Felder】

7.5.5 rk_aiq_wb_cct_t

【Beschreibung】 Weißabgleichsverstärkungsparameter definieren.

【Definition】

 typedef struct rk_aiq_wb_cct_s {
     float CCT;
     float CCRI;
 } rk_aiq_wb_cct_t;

【Felder】

7.5.6 rk_aiq_wb_mwb_attrib_t

【Beschreibung】 Eigenschaften des manuellen Weißabgleichs definieren.

【Definition】

 typedef struct rk_aiq_wb_mwb_attrib_s {
     rk_aiq_wb_mwb_mode_t mode;
     union MWBPara_u {
         rk_aiq_wb_gain_t gain;
         rk_aiq_wb_scene_t scene;
         rk_aiq_wb_cct_t cct;
     } para;
 } rk_aiq_wb_mwb_attrib_t;

【Felder】

7.5.7 rk_aiq_uapiV2_wb_awb_wbGainOffset_t

【Beschreibung】 Offset der automatischen Weißabgleichsverstärkung definieren.

【Definition】

 typedef struct rk_aiq_uapiV2_wb_awb_wbGainOffset_s{
   rk_aiq_uapi_sync_t sync;
   CalibDbV2_Awb_gain_offset_cfg_t gainOffset;
 }rk_aiq_uapiV2_wb_awb_wbGainOffset_t;

【Felder】

7.5.8 CalibDbV2_Awb_gain_offset_cfg_t

【Beschreibung】 Offset der automatischen Weißabgleichsverstärkung definieren.

【Definition】

 typedef struct CalibDbV2_Awb_gain_offset_cfg_s{
   bool enable;
   float offset[4];
 }CalibDbV2_Awb_gain_offset_cfg_t;

【Felder】

7.5.9 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t

【Beschreibung】 Farbtonanpassungsparameter des automatischen Weißabgleichs definieren.

【Definition】

 typedef struct rk_aiq_uapiV2_wb_awb_wbGainAdjustLut_s {
   float lumaValue;
   int ct_grid_num;
   int cri_grid_num;
   float ct_in_range[2];//min,max, equal distance sapmle
   float cri_in_range[2];//min,max
   float *ct_lut_out;//size is ct_grid_num*cri_grid_num
   float *cri_lut_out;
 } rk_aiq_uapiV2_wb_awb_wbGainAdjustLut_t;
 typedef struct rk_aiq_uapiV2_wb_awb_wbGainAdjust_s {
   rk_aiq_uapi_sync_t sync;
   bool enable;
   rk_aiq_uapiV2_wb_awb_wbGainAdjustLut_t *lutAll;
   int lutAll_len;
 } rk_aiq_uapiV2_wb_awb_wbGainAdjust_t;

【Felder】

Weitere Hinweise enthält das Kapitel zur WBGain-Farbanpassung im Dokument Rockchip_Color_Optimization_Guide.

7.5.10 rk_aiq_uapiV2_wbV30_awb_attrib_t

【Beschreibung】 API-Parameter des automatischen Weißabgleichs definieren.

【Definition】

 typedef struct rk_aiq_uapiV2_wbV30_awb_attrib_s {
     rk_aiq_uapiV2_wb_awb_wbGainAdjust_t wbGainAdjust;
     CalibDbV2_Awb_gain_offset_cfg_t wbGainOffset;
 } rk_aiq_uapiV2_wbV30_awb_attrib_t;

【Felder】

7.5.11 rk_aiq_uapiV2_wbV32_attrib_t

【Beschreibung】 Alle von der Weißabgleichs-API unterstützten Parameter definieren.

【Definition】

 typedef struct rk_aiq_uapiV2_wbV30_attrib_s {
     rk_aiq_uapi_sync_t sync;
     bool byPass;
     rk_aiq_wb_op_mode_t mode;
     rk_aiq_wb_mwb_attrib_t stManual;
     rk_aiq_uapiV2_wbV30_awb_attrib_t stAuto;
 } rk_aiq_uapiV2_wbV30_attrib_t;

【Felder】

7.6 Referenz der modulbezogenen APIs

7.6.1 rk_aiq_user_api2_awbV30_SetAllAttrib

【Beschreibung】 Alle von der Weißabgleichs-API unterstützten Parameter einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awbV30_SetAllAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wbV30_attrib_t attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.2 rk_aiq_user_api2_awbV30_GetAllAttrib

【Beschreibung】 Alle von der Weißabgleichs-API unterstützten Parameter abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awbV30_GetAllAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wbV30_attrib_t *attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.3 rk_aiq_user_api2_awb_GetCCT

【Beschreibung】 Farbtemperatur des Weißabgleichs abrufen. Diese Funktion gilt für automatischen und manuellen Betrieb.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_GetCCT(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_wb_cct_t
 *cct);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.4 rk_aiq_user_api2_awb_QueryWBInfo

【Beschreibung】 Weißabgleichsverstärkungsfaktor und Farbtemperatur abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_QueryWBInfo(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_wb_querry_info_t *wb_querry_info);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.5 rk_aiq_user_api2_awb_Lock

【Beschreibung】 Aktuelle Weißabgleichsparameter sperren.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_Lock(const rk_aiq_sys_ctx_t* sys_ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.6 rk_aiq_user_api2_awb_Unlock

【Beschreibung】 Gesperrte Weißabgleichsparameter wieder freigeben.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_Lock(const rk_aiq_sys_ctx_t* sys_ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.7 rk_aiq_user_api2_awb_SetWpModeAttrib

【Beschreibung】 Weißabgleichsbetriebsart einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_SetWpModeAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_opMode_t attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.8 rk_aiq_user_api2_awb_GetWpModeAttrib

【Beschreibung】 Weißabgleichsbetriebsart abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_GetWpModeAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_opMode_t *attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.9 rk_aiq_user_api2_awb_SetMwbAttrib

【Beschreibung】 Manuelle Weißabgleichsparameter einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_SetMwbAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_wb_mwb_attrib_t attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.10 rk_aiq_user_api2_awb_GetMwbAttrib

【Beschreibung】 Manuelle Weißabgleichsparameter einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_SetMwbAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_wb_mwb_attrib_t attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.11 rk_aiq_user_api2_awb_SetWbGainAdjustAttrib

【Beschreibung】 Farbtonanpassungsparameter im automatischen Weißabgleichsmodus einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_SetWbGainAdjustAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.12 rk_aiq_user_api2_awb_GetWbGainAdjustAttrib

【Beschreibung】 Farbtonanpassungsparameter im automatischen Weißabgleichsmodus abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_GetWbGainAdjustAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_awb_wbGainAdjust_t *attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.13 rk_aiq_user_api2_awb_SetWbGainOffsetAttrib

【Beschreibung】 Offset der automatischen Weißabgleichsverstärkung einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_SetWbGainOffsetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_awb_wbGainOffset_t attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.6.14 rk_aiq_user_api2_awb_GetWbGainOffsetAttrib

【Beschreibung】 Offset der automatischen Weißabgleichsverstärkung abrufen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_awb_GetWbGainOffsetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 rk_aiq_uapiV2_wb_awb_wbGainOffset_t *attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdateien: rk_aiq_user_api2_awb.h, rk_aiq_uapi2_awb_int.h

Bibliotheksdatei: librkaiq.so

【Beispiel】

Siehe sample_awb_module.cpp.

7.7 Datentypen der modulbezogenen APIs

7.7.1 rk_aiq_wb_querry_info_t

【Beschreibung】 Weißabgleichsabfrageinformationen definieren.

【Definition】

 typedef struct rk_aiq_wb_querry_info_s {
     rk_aiq_wb_gain_t gain;
     rk_aiq_wb_cct_t cctGloabl;
     bool awbConverged;
     uint32_t LVValue;
 } rk_aiq_wb_querry_info_t;

【Felder】

7.7.2 rk_aiq_wb_op_mode_t

【Beschreibung】 Weißabgleichsbetriebsart definieren.

【Definition】

 typedef struct rk_aiq_uapiV2_wb_opMode_s {
   rk_aiq_uapi_sync_t sync;
   rk_aiq_wb_op_mode_t mode;
 } rk_aiq_uapiV2_wb_opMode_t;

【Felder】

7.7.3 rk_aiq_wb_mwb_attrib_t

【Beschreibung】 Eigenschaften des manuellen Weißabgleichs definieren.

【Definition】

 typedef struct rk_aiq_wb_mwb_attrib_s {
      rk_aiq_uapi_sync_t sync;
     rk_aiq_wb_mwb_mode_t mode;
     union MWBPara_u {
         rk_aiq_wb_gain_t gain;
         rk_aiq_wb_scene_t scene;
         rk_aiq_wb_cct_t cct;
     } para;
 } rk_aiq_wb_mwb_attrib_t;

【Felder】

8. AF

8.1 Überblick

Das AF-Modul stellt das Kameraobjektiv so ein, dass das Motiv scharf abgebildet wird.

8.2 Funktionsbeschreibung

Das AF-Modul besteht aus AF-Informationsstatistik und AF-Steueralgorithmus. Das folgende Blockbild zeigt die Statistik:

ch0/ch1/ch2 entsprechen im HDR-Modus den S/M/L-Frames; debayer bezeichnet den zusammengesetzten HDR-Frame.

windowA liefert hauptsächlich 15*15 V1/V2/H1/H2-FV-Werte, Helligkeitsinformationen und die Anzahl heller Pixel.

windowB liefert hauptsächlich einen FV-Wert, Helligkeitsinformationen und die Anzahl heller Pixel.

8.3 userAF-Algorithmen entwickeln

Referenzcode im SDK: external/camera_engine_rkaiq/rkisp_demo/demo/af_algo_demo

8.4 Funktionsbezogene API-Referenz

8.4.1 rk_aiq_uapi2_setFocusMode

【Beschreibung】 Fokusmodus konfigurieren.

【Syntax】

 XCamReturn rk_aiq_uapi2_setFocusMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.2 rk_aiq_uapi2_getFocusMode

【Beschreibung】 Aktuellen Fokusmodus abfragen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getFocusMode(const rk_aiq_sys_ctx_t* ctx, opMode_t
 *mode);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.3 rk_aiq_uapi2_setFocusWin

【Beschreibung】 Autofokusfenster einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setFocusWin(const rk_aiq_sys_ctx_t* ctx, paRect_t *rect);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.4 rk_aiq_uapi2_getFocusWin

【Beschreibung】 Autofokusfenster einstellen. Die getFocusWin-Beschreibung lautet im Original ebenfalls „Set“; dies bleibt als Quellenabweichung erhalten.

【Syntax】

 XCamReturn rk_aiq_uapi2_getFocusWin(const rk_aiq_sys_ctx_t* ctx, paRect_t *rect);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.5 rk_aiq_uapi2_lockFocus

【Beschreibung】 Autofokus sperren und die Fokusbewegung pausieren.

【Syntax】

 XCamReturn rk_aiq_uapi2_lockFocus(const rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.6 rk_aiq_uapi2_unlockFocus

【Beschreibung】 Autofokus entsperren und Fokusbewegung fortsetzen.

【Syntax】

 XCamReturn rk_aiq_uapi2_unlockFocus(const rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.7 rk_aiq_uapi2_oneshotFocus

【Beschreibung】 Einmalige Fokussierung auslösen; nach Abschluss wird nicht weiter fokussiert.

【Syntax】

 XCamReturn rk_aiq_uapi2_oneshotFocus(const rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.8 rk_aiq_uapi2_manualTrigerFocus

【Beschreibung】 Fokussierung manuell auslösen. Anschließend die Bildunschärfe weiter überwachen und bei erneuter Unschärfe nochmals fokussieren.

【Syntax】

 XCamReturn rk_aiq_uapi2_manualTrigerFocus(const rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.9 rk_aiq_uapi2_trackingFocus

【Beschreibung】 Bildunschärfe fortlaufend überwachen und bei Bedarf erneut fokussieren. Üblicherweise nach rk_aiq_uapi2_oneshotFocus verwenden.

【Syntax】

 XCamReturn rk_aiq_uapi2_trackingFocus(const rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.10 rk_aiq_uapi2_getSearchResult

【Beschreibung】 Fokussierergebnis abfragen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getSearchResult(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_af_result_t* result);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.11 rk_aiq_uapi2_getZoomRange

【Beschreibung】 Zoombereich abfragen. Er begrenzt die Zoomcode-Eingabe von rk_aiq_uapi_setOpZoomPosition; die API-Schreibweise der Quelle bleibt erhalten.

【Syntax】

 XCamReturn rk_aiq_uapi2_getZoomRange(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_af_zoomrange* range);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.12 rk_aiq_uapi2_setOpZoomPosition

【Beschreibung】 Zoomposition einstellen beziehungsweise ändern.

【Syntax】

 XCamReturn rk_aiq_uapi2_setOpZoomPosition(const rk_aiq_sys_ctx_t* ctx, int pos);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.13 rk_aiq_uapi2_getOpZoomPosition

【Beschreibung】 Zoomposition abfragen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getOpZoomPosition(const rk_aiq_sys_ctx_t* ctx, int *pos);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.14 rk_aiq_uapi2_endOpZoomChange

【Beschreibung】 Einstellung der Zoommotorposition abschließen. Nach rk_aiq_uapi_setOpZoomPosition aufrufen; danach erfolgt die Fokussierung. Die API-Schreibweise der Quelle bleibt erhalten.

【Syntax】

 XCamReturn rk_aiq_uapi2_endOpZoomChange(const rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.15 rk_aiq_uapi2_getFocusRange

【Beschreibung】 Fokusbereich abfragen. Er begrenzt den Fokuscode von rk_aiq_uapi_setFocusPosition; die API-Schreibweise der Quelle bleibt erhalten.

【Syntax】

 XCamReturn rk_aiq_uapi2_getFocusRange(const rk_aiq_sys_ctx_t* ctx,
 rk_aiq_af_focusrange* range);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.16 rk_aiq_uapi2_setFocusPosition

【Beschreibung】 Fokusposition im manuellen Fokusmodus einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setFocusPosition(const rk_aiq_sys_ctx_t* ctx, unsigned
 short code);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.17 rk_aiq_uapi2_getFocusPosition

【Beschreibung】 Aktuelle Fokusposition abfragen.

【Syntax】

 XCamReturn rk_aiq_uapi2_getFocusPosition(const rk_aiq_sys_ctx_t* ctx, unsigned
 short *code);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.18 rk_aiq_uapi2_startZoomCalib

【Beschreibung】 Elektromotormodul korrigieren.

【Syntax】

 XCamReturn rk_aiq_uapi2_startZoomCalib(const rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.4.19 rk_aiq_uapi2_resetZoom

【Beschreibung】 Elektromotormodul zurücksetzen.

【Syntax】

 XCamReturn rk_aiq_uapi2_resetZoom(const rk_aiq_sys_ctx_t* ctx);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

8.5 Datentypen der funktionsbezogenen APIs

8.5.1 opMode_t

【Beschreibung】 Betriebsmodus der AF-Informationsstatistik definieren.

【Definition】

 typedef enum opMode_e {
     OP_AUTO   = 0,
     OP_MANUAL = 1,
     OP_SEMI_AUTO = 2,
     OP_INVAL
 } opMode_t;

【Felder】

8.5.2 rk_aiq_af_zoomrange

【Beschreibung】 Wertebereich des Zooms definieren.

【Definition】

 typedef struct {
     int min_pos;
     int max_pos;
     float min_fl;
     float max_fl;
 } rk_aiq_af_zoomrange;

【Felder】

8.5.3 rk_aiq_af_focusrange

【Beschreibung】 Wertebereich des Fokus definieren.

【Definition】

 typedef struct {
     int min_pos;
     int max_pos;
 } rk_aiq_af_focusrange;

【Felder】

8.5.4 rk_aiq_af_result_t

【Beschreibung】 AF-Suchergebnisse definieren.

【Definition】

 typedef enum rk_aiq_af_sec_stat_e
 {
     RK_AIQ_AF_SEARCH_INVAL   = 0,
     RK_AIQ_AF_SEARCH_RUNNING = 1,
     RK_AIQ_AF_SEARCH_END     = 2
 } rk_aiq_af_sec_stat_t;
 typedef struct {
     rk_aiq_af_sec_stat_t stat;
     int32_t final_pos;
 } rk_aiq_af_result_t;

【Felder】

8.6 Modulbezogene API-Referenz

8.6.1 rk_aiq_user_api2_af_SetAttrib

【Beschreibung】 Fokuseigenschaften einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_af_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_af_attrib_t
 attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_af.h

Bibliotheksdatei: librkaiq.so

8.6.2 rk_aiq_user_api2_af_GetAttrib

【Beschreibung】 Fokuseigenschaften abfragen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_af_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_af_attrib_t
 *attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_af.h

Bibliotheksdatei: librkaiq.so

8.7 Datentypen der modulbezogenen APIs

8.7.1 RKAIQ_AF_MODE

【Beschreibung】 Fokusbetriebsmodus definieren.

【Definition】

 typedef enum _RKAIQ_AF_MODE
 {
     RKAIQ_AF_MODE_NOT_SET = -1,
     RKAIQ_AF_MODE_AUTO,
     RKAIQ_AF_MODE_MACRO,
     RKAIQ_AF_MODE_INFINITY,
     RKAIQ_AF_MODE_FIXED,
     RKAIQ_AF_MODE_EDOF,
     RKAIQ_AF_MODE_CONTINUOUS_VIDEO,
     RKAIQ_AF_MODE_CONTINUOUS_PICTURE,
     RKAIQ_AF_MODE_ONESHOT_AFTER_ZOOM,
 } RKAIQ_AF_MODE;

【Felder】

8.7.2 RKAIQ_AF_HWVER

【Beschreibung】 Fokusbetriebsmodus definieren. Die Quelle verwendet diese Beschreibung auch für RKAIQ_AF_HWVER; die Typ-/Beschreibungsabweichung bleibt dokumentiert.

【Definition】

 typedef enum _RKAIQ_AF_HWVER
 {
     RKAIQ_AF_HW_V20 = 0,
     RKAIQ_AF_HW_V30,
     RKAIQ_AF_HW_VMAX
 } RKAIQ_AF_HWVER;

【Felder】

8.7.3 rk_aiq_af_algo_meas_v30_t

【Beschreibung】 Betriebsmodus der AF-Informationsstatistik definieren.

【Definition】

 typedef struct {
     unsigned char af_en;
     unsigned char rawaf_sel;
     unsigned char gamma_en;
     unsigned char gaus_en;
     unsigned char v1_fir_sel;
     unsigned char hiir_en;
     unsigned char viir_en;
     unsigned char v1_fv_outmode;    // 0 square, 1 absolute
     unsigned char v2_fv_outmode;    // 0 square, 1 absolute
     unsigned char h1_fv_outmode;    // 0 square, 1 absolute
     unsigned char h2_fv_outmode;    // 0 square, 1 absolute
     unsigned char ldg_en;
     unsigned char accu_8bit_mode;   //fix to 1
     unsigned char ae_mode;
     unsigned char y_mode;           //fix to 0
     unsigned char line_en[RKAIQ_RAWAF_LINE_NUM];
     unsigned char line_num[RKAIQ_RAWAF_LINE_NUM];
     unsigned char window_num;
     unsigned short wina_h_offs;
     unsigned short wina_v_offs;
     unsigned short wina_h_size;
     unsigned short wina_v_size;
     unsigned short winb_h_offs;
     unsigned short winb_v_offs;
     unsigned short winb_h_size;
     unsigned short winb_v_size;
     unsigned short gamma_y[RKAIQ_RAWAF_GAMMA_NUM];
     // [old version param]
     unsigned short thres;
     unsigned char shift_sum_a;
     unsigned char shift_sum_b;
     unsigned char shift_y_a;
     unsigned char shift_y_b;

     /**********[Vertical IIR (v1 & v2)]************/
     short v1_iir_coe[9];
     short v1_fir_coe[3];
     short v2_iir_coe[3];
     short v2_fir_coe[3];
     /**********[Horizontal IIR (h1 & h2)]************/
     short h1_iir1_coe[6];
     short h2_iir1_coe[6];
     short h1_iir2_coe[6];
     short h2_iir2_coe[6];
     /**********[Focus value statistic param]**********/
     // level depended gain
     // input8 lumi, output8bit gain
     unsigned char h_ldg_lumth[2];    //luminance thresh
     unsigned char h_ldg_gain[2];     //gain for [minLum,maxLum]
     unsigned short h_ldg_gslp[2];    //[slope_low,-slope_high]
     unsigned char v_ldg_lumth[2];
     unsigned char v_ldg_gain[2];
     unsigned short v_ldg_gslp[2];
     // coring
     unsigned short v_fv_thresh;
     unsigned short h_fv_thresh;
     // left shift, more needed if outmode=square
     unsigned char v1_fv_shift; //only for sel1
     unsigned char v2_fv_shift;
     unsigned char h1_fv_shift;
     unsigned char h2_fv_shift;
     /**********[High light]**********/
     unsigned short highlit_thresh;
 }  rk_aiq_af_algo_meas_v30_t;

【Felder】

8.7.4 rk_aiq_af_attrib_t

【Beschreibung】 Fokuskonfigurationsinformationen.

【Definition】

 typedef struct rk_aiq_af_attrib_s {
     rk_aiq_uapi_sync_t sync;
     RKAIQ_AF_MODE AfMode;
     RKAIQ_AF_HWVER AfHwVer;
     bool contrast_af;
     bool laser_af;
     bool pdaf;
     int h_offs;
     int v_offs;
     unsigned int h_size;
     unsigned int v_size;
     short fixedModeDefCode;
     short macroModeDefCode;
     short infinityModeDefCode;
     union {
         rk_aiq_af_algo_meas_v20_t manual_meascfg;
         rk_aiq_af_algo_meas_v30_t manual_meascfg_v30;
     };
 } rk_aiq_af_attrib_t;

【Felder】

8.8 Ergänzende Hinweise

8.8.1 VCM-Motormodultreiber prüfen

1. Prüfen, ob Anfangs- und Endstrom des VCM-Treibers korrekt eingestellt sind.

Zunächst die Angaben zu Anfangs- und Endstrom vom Modulhersteller einholen.

Anschließend einige Module auswählen und die Angaben wie folgt prüfen:

Im DTS Anfangs- und Endstrom auf den maximal vom VCM unterstützten Bereich setzen.

Auf manuellen Fokus wechseln und die VCM-Position schrittweise ab 64 ändern. Sobald das Objektiv sich bewegt und ein fernes Objekt über 10 Meter scharf ist, die aktuelle Position notieren.

Der Anfangsstrom beträgt (vcm_max_mA - vcm_min_mA) * (64 - curPos) / 64.

VCM weiter bewegen. Sobald ein nahes Objekt bei 10cm oder 20cm scharf erscheint, die aktuelle Position notieren.

Der Endstrom beträgt (vcm_max_mA - vcm_min_mA) * (64 - curPos) / 64.

2. Prüfen, ob die Endposition bei Bewegung aus verschiedenen Richtungen stabil ist.

Im manuellen Fokusmodus eine Zielposition wählen. Einmal von 0, einmal von 64 dorthin bewegen. Bildschärfe und AF-Statistik beider Ergebnisse vergleichen.

3. Prüfen, ob die benötigte Objektivbewegungszeit korrekt ist.

8.8.2 Elektromotormodultreiber prüfen

1. Prüfen, ob mehrere Einzelschritte und eine mehrschrittige Bewegung an derselben Position enden.

1. Zunächst eine Zoom-/Fokusmotorposition mit maximaler Bildschärfe wählen, die Position notieren und Bild A aufnehmen.

2. Zoom- oder Fokusmotor um einige Schritte zurückfahren und dann in Einzelschritten zur notierten Position bewegen. Bild B aufnehmen.

3. Erneut um einige Schritte zurückfahren, die notierte Position mit einer einzigen Bewegung anfahren und Bild C aufnehmen.

4. Schärfe und Sichtfeld von A, B und C auf Übereinstimmung prüfen.

2. Prüfen, ob zufällige Motorbewegungen an derselben Zielposition enden.

1. Zunächst eine Zoom-/Fokusmotorposition mit maximaler Bildschärfe wählen, die Position notieren und Bild A aufnehmen.

2. Zoom- oder Fokusmotor per Skript 400 bis 500 zufällige Bewegungen ausführen lassen, zur ursprünglichen Position zurückkehren und Bild B aufnehmen.

3. Bild A und B auf gleiche Schärfe und gleiches Sichtfeld prüfen.

3. Prüfen, ob gleichzeitig bewegte Motoren dieselbe Endposition erreichen.

1. Zunächst eine Zoom-/Fokusmotorposition mit maximaler Bildschärfe wählen, die Position notieren und Bild A aufnehmen.

2. Zoom- und Fokusmotor per Skript gleichzeitig 400 bis 500 zufällige Bewegungen ausführen lassen, zur ursprünglichen Position zurückkehren und Bild B aufnehmen.

3. Bild A und B auf gleiche Schärfe und gleiches Sichtfeld prüfen.

9. IMGPROC

9.1 Überblick

imgproc bezeichnet die Module, die die Bildwirkung beeinflussen.

9.2 Merge

9.2.1 Funktionsbeschreibung

Merge führt mehrere Bildframes zu einem einzelnen Frame zusammen.

9.2.2 Wichtige Begriffe

Wirkt ausschließlich im HDR-Modus.

9.2.3 Funktionsbezogene API-Referenz

9.2.4 Modulbezogene API-Referenz

9.2.4.1 rk_aiq_user_api2_amerge_SetAttrib

【Beschreibung】 Merge-Eigenschaften einstellen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_amerge_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 amerge_attrib_t attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_amerge.h

Bibliotheksdatei: librkaiq.so

9.2.4.2 rk_aiq_user_api2_amerge_GetAttrib

【Beschreibung】 Merge-Eigenschaften abfragen.

【Syntax】

 XCamReturn
 rk_aiq_user_api2_amerge_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
 amerge_attrib_t* attr);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_amerge.h

Bibliotheksdatei: librkaiq.so

9.2.5 Datentypen der modulbezogenen APIs

9.2.5.1 merge_OpMode_t

【Beschreibung】 Merge-Betriebsmodus definieren.

【Definition】

 typedef enum merge_OpModeV21_e {
     MERGE_OPMODE_API_OFF = 0,
     MERGE_OPMODE_MANU    = 1,
 } merge_OpModeV21_t;

【Felder】

9.2.5.2 MergeBaseFrame_t

【Beschreibung】 Referenzframe-Eigenschaften beim Zusammenführen definieren.

【Definition】

 typedef enum MergeBaseFrame_e {
     BASEFRAME_LONG  = 0,
     BASEFRAME_SHORT = 1,
 } MergeBaseFrame_t;

【Felder】

9.2.5.3 MergeCurrCtlData_t

【Beschreibung】 Merge-Steuerparameter definieren.

【Definition】

 typedef struct MergeCurrCtlData_s {
     float Envlv;
     float MoveCoef;
 } MergeCurrCtlData_t;

【Felder】

9.2.5.4 mMergeOECurveV21_t

【Beschreibung】 Eigenschaften der manuellen Merge-Überbelichtungskurve definieren.

【Definition】

 typedef struct mMergeOECurveV21_s {
     float Smooth;
     float Offset;
 } mMergeOECurveV21_t;

【Felder】

9.2.5.5 mMergeMDCurveV21_t

【Beschreibung】 Bewegungskurveneigenschaften im Langframe-Modus definieren.

【Definition】

 typedef struct mMergeMDCurveV21_s {
     float LM_smooth;
     float LM_offset;
     float MS_smooth;
     float MS_offset;
 } mMergeMDCurveV21_t;

【Felder】

9.2.5.6 mMergeAttrV21_t

【Beschreibung】 Manuelle Merge-Eigenschaften für RK3588 definieren.

【Definition】

 typedef struct mMergeAttrV21_s {
     mMergeOECurveV21_t OECurve;
     mMergeMDCurveV21_t MDCurve;
 } mMergeAttrV21_t;

【Felder】

9.2.5.7 mergeAttrV21_t

【Beschreibung】 Merge-Eigenschaften auf RK356x konfigurieren.

【Definition】

 typedef struct mergeAttrV21_s {
     merge_OpModeV21_t    opMode;
     mMergeAttrV21_t      stManual;
     MergeCurrCtlData_t   CtlInfo;
 } mergeAttrV21_t;

【Felder】

9.2.5.8 mLongFrameModeData_t

【Beschreibung】 Steuerparameter im Langframe-Modus definieren.

【Definition】

 typedef struct mLongFrameModeData_s {
     mMergeOECurveV21_t OECurve;
     mMergeMDCurveV21_t MDCurve;
 } mLongFrameModeData_t;

【Felder】

9.2.5.9 mMergeMDCurveV30Short_t

【Beschreibung】 Bewegungskurveneigenschaften im Kurzframe-Modus definieren.

【Definition】

 typedef struct mMergeMDCurveV30Short_s{
     float Coef;
     float ms_thd0;
     float lm_thd0;
 } mMergeMDCurveV30Short_t;

【Felder】

9.2.5.10 mShortFrameModeData_t

【Beschreibung】 Steuerparameter im Kurzframe-Modus definieren.

【Definition】

 typedef struct mShortFrameModeData_s {
     mMergeOECurveV21_t      OECurve;
     mMergeMDCurveV30Short_t MDCurve;
 } mShortFrameModeData_t;

【Felder】

9.2.5.11 mMergeAttrV30_t

【Beschreibung】 Manuelle Merge-Eigenschaften für RK3588 definieren.

【Definition】

 typedef struct mMergeAttrV30_s {
     MergeBaseFrame_t      BaseFrm;
     mLongFrameModeData_t  LongFrmModeData;
     mShortFrameModeData_t ShortFrmModeData;
 } mMergeAttrV30_t;

【Felder】

9.2.5.12 MergeOECurveV10_t

【Beschreibung】 Automatische Merge-Überbelichtungskurve definieren.

【Definition】

 typedef struct MergeOECurveV10_s {
     float EnvLv[MERGE_ENVLV_STEP_MAX];
     float Smooth[MERGE_ENVLV_STEP_MAX];
     float Offset[MERGE_ENVLV_STEP_MAX];
 } MergeOECurveV10_t;

【Felder】

9.2.5.13 MergeMDCurveV10_t

【Beschreibung】 Bewegungskurveneigenschaften im Langframe-Modus definieren.

【Definition】

 typedef struct MergeMDCurveV10_s {
     float MoveCoef[MERGE_ENVLV_STEP_MAX];
     float LM_smooth[MERGE_ENVLV_STEP_MAX];
     float LM_offset[MERGE_ENVLV_STEP_MAX];
     float MS_smooth[MERGE_ENVLV_STEP_MAX];
     float MS_offset[MERGE_ENVLV_STEP_MAX];
 } MergeMDCurveV10_t;

【Felder】

9.2.5.14 MergeEachChnCurveV12_t

【Beschreibung】 Unterkanal-Erkennungskurve im Langframe-Modus definieren.

【Definition】

 typedef struct MergeEachChnCurveV12_s {
     float EnvLv[MERGE_ENVLV_STEP_MAX];
     float Smooth[MERGE_ENVLV_STEP_MAX];
     float Offset[MERGE_ENVLV_STEP_MAX];
 } MergeEachChnCurveV12_t;

【Felder】

9.2.5.15 LongFrameModeDataV12_t

【Beschreibung】 Steuerparameter im Langframe-Modus definieren.

【Definition】

 typedef struct LongFrameModeDataV12_s {
     bool                   EnableEachChn;
     MergeOECurveV10_t      OECurve;
     MergeMDCurveV10_t      MDCurve;
     MergeEachChnCurveV12_t EachChnCurve;
     float                  OECurve_damp;
     float                  MDCurveLM_damp;
     float                  MDCurveMS_damp;
 } LongFrameModeDataV12_t;

【Felder】

9.2.5.16 MergeMDCurveV11Short_t

【Beschreibung】 Bewegungskurveneigenschaften im Kurzframe-Modus definieren.

【Definition】

 typedef struct MergeMDCurveV11Short_s{
     float Coef;
     float ms_thd0;
     float lm_thd0;
 } MergeMDCurveV11Short_t;

【Felder】

9.2.5.17 ShortFrameModeData_t

【Beschreibung】 Steuerparameter im Kurzframe-Modus definieren.

【Definition】

 typedef struct ShortFrameModeData_s {
     MergeOECurveV10_t      OECurve;
     MergeMDCurveV11Short_t MDCurve;
     float                  OECurve_damp;
     float                  MDCurve_damp;
 } ShortFrameModeData_t;

【Felder】

9.2.5.18 CalibDbV2_merge_V12_t

【Beschreibung】 Automatische Merge-Eigenschaften definieren.

【Definition】

 typedef struct CalibDbV2_merge_V12_s {
     MergeBaseFrame_t       BaseFrm;
     float                  ByPassThr;
     LongFrameModeDataV12_t LongFrmModeData;
     ShortFrameModeData_t   ShortFrmModeData;
 } CalibDbV2_merge_V12_t;

【Felder】

9.2.5.19 MergeCurrCtlData_t

【Beschreibung】 Merge-Eigenschaften auf RK3588 konfigurieren.

【Definition】

 typedef struct mergeAttrV30_s {
     merge_OpModeV21_t    opMode;
     mMergeAttrV30_t      stManual;
     MergeCurrCtlData_t   CtlInfo;
 } mergeAttrV30_t;

【Felder】

9.2.5.20 mergeAttr_t

【Beschreibung】 Merge-Eigenschaften konfigurieren.

【Definition】

 typedef struct mergeAttr_s {
     rk_aiq_uapi_sync_t  sync;
     mergeAttrV21_t      attrV21;
     mergeAttrV30_t      attrV30;
 } mergeAttr_t;

【Felder】

9.3 DRC

9.3.1 Funktionsbeschreibung

DRC (High Dynamic Range Compression) komprimiert Bilder mit hoher Bittiefe in Bilder mit niedriger Bittiefe.

9.3.2 Wichtige Begriffe

DRC ist sowohl im Linear- als auch im HDR-Modus nutzbar.

9.3.3 Funktionsbezogene API-Referenz

9.3.3.1 rk_aiq_uapi2_setDrcGain

【Beschreibung】

Parameter der DrcGain-Kurve schnell einstellen.

【Syntax】

 XCamReturn rk_aiq_uapi2_setDrcGain(const rk_aiq_sys_ctx_t* ctx, float Gain, float
 Alpha, float Clip);

Der API-Modus ist dabei DRC_OPMODE_DRC_GAIN. Der Aufruf speichert die Parameter in stDrcGain; dieses bestimmt die drei Parameter der DrcGain-Kurve. Die übrigen DRC-Parameter werden weiterhin vom DRC-Modul der JSON-Datei bestimmt.

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

9.3.3.2 rk_aiq_uapi2_getDrcGain

【Beschreibung】

Parameter der schnellen DrcGain-Kurve abfragen.

Die API liefert die Werte aus stDrcGain. Nur im API-Modus DRC_OPMODE_DRC_GAIN entsprechen sie den tatsächlich verwendeten aktuellen Parametern.

【Syntax】

 XCamReturn rk_aiq_uapi2_getDrcGain(const rk_aiq_sys_ctx_t* ctx, float Gain, float
 Alpha, float Clip);

【Parameter】

【Rückgabewert】

【Voraussetzungen】

Headerdatei: rk_aiq_user_api2_imgproc.h

Bibliotheksdatei: librkaiq.so

9.3.3.3 rk_aiq_uapi2_setDrcHiLit

【Beschreibung】

DrcHiLit-Parameter schnell einstellen.

Dabei gilt DRC_OPMODE_HILIT. Der API-Aufruf speichert die Werte in stHiLit, das die HiLight-Parameter bestimmt. Alle übrigen DRC-Parameter stammen weiterhin aus dem DRC-Modul der JSON-Datei.

【Syntax】

 XCamReturn rk_aiq_uapi2_setDrcHiLit(const rk_aiq_sys_ctx_t* ctx, float Strength);

【Parameter】