Rockchip-Kameramodul-OTP-Kalibrierung: AWB, LSC, PDAF, APIs und Datenformate

Dieser Artikel bewahrt den vollständigen technischen Haupttext (PDF S. 9–47) der 47-seitigen englischen Quelle V1.0.34. Eine entsprechende chinesische PDF-Datei wurde nicht bereitgestellt. Die chinesische und russische Fassung übersetzen die englische Quelle vollständig; die drei bisherigen Artikel verwenden Originalabbildungen aus der englischen PDF-Datei, einschließlich darin bereits vorhandener chinesischer Beschriftungen. Auch diese deutsche Fassung übernimmt dieselben Originalabbildungen und übersetzt den vollständigen englischen Artikel. Code, Parameter, Bezeichner, Beispielwerte und Codekommentare bleiben im Quelltext erhalten; Fließtext und Bildunterschriften werden lokalisiert.

Die Chipsätze im Geltungsbereich der Quelle sind unten aufgeführt. Die Quelle nennt weder eine einheitliche Kernelversion noch bestimmte ArmSoM-Platinen. Dies ist eine ArmSoM-Plattformreferenz: Prüfen Sie den tatsächlichen SoC, das Modul, den Sensor, VCM/OIS, ISP, SDK/BSP, die Version der Kalibrierungs-DLL/API, die Treiber und das OTP-/EEPROM-Layout. Die Modulbeispiele der Quelle sind keine ArmSoM-Testergebnisse. Es wurden keine Hardwarevalidierung, Kalibrierung, Programmierung oder Kameraoperationen durchgeführt.

Betriebsrisiko und Quellenhinweise: OTP-/EEPROM-Programmierung kann irreversibel sein oder die Modulkalibrierung überschreiben. Prüfen Sie zuerst den Herstellerablauf und das Speicherlayout des Zielgeräts. Mehrere Standardwerte, Funktionsdeklarationen und Aufrufe im Anhang unterscheiden sich in der Quelle. Der Anhang ist ein Quellenbeispiel, keine Garantie für Kompilierbarkeit oder Produktionstauglichkeit. Formeln, Adressen, Bitbreiten und IDs behalten die Quellwerte bei; technische Konstanten wurden nicht stillschweigend korrigiert.

Quellenhinweise und Prüfprotokoll: EDITORIAL-NOTES. ArmSoM · Rockchip Linux

1 LSC- und AWB-Kalibrierungsablauf

1.1 Kalibrierungsverfahren

1. Lichtumgebung und Ausrüstung

D50 (5000K±100K), unter Vermeidung von Störlicht aus der Umgebung.

Ein Homogenisator oder eine DNP-Lichtbox, die der obigen Lichtquelle entspricht. Der Homogenisator ist in der folgenden Abbildung dargestellt:

Technische Abbildung aus der englischen Quelle, PDF S. 9.

2. Aufnahmeverfahren

1. Wählen Sie je nach den tatsächlichen Gegebenheiten eines der folgenden beiden Verfahren:

1. Mit Homogenisator: Platzieren Sie dessen beschichtete Seite nahe vor dem Objektiv und zum Objektiv hin ausgerichtet; halten Sie die Stirnfläche des Moduls, den Homogenisator und die Lichtquellenfläche parallel.
2. Mit DNP-Lichtbox: Platzieren Sie das Modul 1-2cm vor der DNP-Lichtquellenfläche und halten Sie die Stirnfläche des Moduls parallel zu dieser Fläche.
3. Deaktivieren Sie Funktionen wie mirror/flip.
4. Wählen Sie die Belichtung so, dass die maximale Helligkeit (8bit) des G-Kanals im Bild zwischen 160~180 liegt.
5. Nehmen Sie mit dieser Belichtung ein RAW-Bild auf und speichern Sie es.

3. AWB-Kalibrierung

1. Wählen Sie den mittleren Bereich des RAW-Bildes (20% der Länge und Breite jedes Kanals) und berechnen Sie die Mittelwerte der Kanäle R, Gr, Gb und B.

Gr_ave=Gr-Mittelwert der ROI - Schwarzpegel

Gb_ave=Gb-Mittelwert der ROI - Schwarzpegel

R_ave = Rot-Mittelwert der ROI - Schwarzpegel

B_ave = Blau-Mittelwert der ROI - Schwarzpegel

2. Berechnen Sie R/Gb, B/Gb und Gr/Gb.

R/Gb=R_ave/Gb_ave

B/Gb=B_ave/Gb_ave

Gr/Gb=Gr_ave/Gb_ave

3. Stellen Sie R/Gb, B/Gb und Gr/Gb als Festkommawerte mit 10 Bits dar: R/Gb_hex=R/Gb * 1024

B/Gb_hex=B/Gb * 1024

Gr/Gb_hex=Gr/Gb * 1024

4. LSC-Kalibrierung

1. Setzen Sie den Zielwert für die Kalibrierungsberechnung auf 70%.

2. Berechnen Sie die Verstärkung jedes der vier Kanäle mit 10 Bits.

1.2 Prüfkriterien

1. Vor der LSC-Kalibrierung

1. Y-Shading-Kriterium:

ROI = 1/5 Width * 1/5Height

YShading_Corner = Y_Corner/Y_Center

30% < YShading_Corner < 55%

Ydiffer = YShading_Corner_Max - YShading_Corner_Min < 7%

2. Color-Shading-Kriterium:

Gleichmäßigkeit der Farbschattierung eines einzelnen Moduls: Begrenzen Sie den Unterschied zwischen jedem Block und dem mittleren Block des Moduls.

ROI-Raster: 1/5*1/5. Berechnen Sie den Unterschied zwischen den 24 Blöcken und dem mittleren Block.

ROI = 1/5Width * 1/5Height

|(R/G_Corner)/(R/G_Center)-1| < 15%

|(B/G_Corner)/(B/G_Center)-1| < 15%

2. LSC-Kalibrierung

Für das Problem einer asymmetrischen Randabschattung in den aufgenommenen RAW-Daten aufgrund der Modulpositionierung wurde der Schnittstelle lsc_otp_Calibrate der Parameter ratio zur Begrenzung des Kalibrierungsergebnisses hinzugefügt (Standard: ratio=1.5).

Verschiebt sich das optische Zentrum aufgrund der Modulmontage selbst, kann ratio erhöht werden, um die Bestehensquote zu verbessern.

3. Nach der LSC-Kalibrierung

1. Y-Shading-Kriterium:

ROI = 1/5 Width * 1/5Height

YShading_Corner = Y_Corner/Y_Center

Ydiffer = YShading_Corner_Max - YShading_Corner_Min < 5%

2. Color-Shading-Kriterium:

Gleichmäßigkeit der Farbschattierung eines einzelnen Moduls: Begrenzen Sie den Unterschied zwischen jedem Block und dem mittleren Block des Moduls.

ROI-Raster: 1/5*1/5. Berechnen Sie den Unterschied zwischen den 24 Blöcken und dem mittleren Block.

ROI = 1/5Width * 1/5Height

|(R/G_Corner)/(R/G_Center)-1| < 5%

|(B/G_Corner)/(B/G_Center)-1| < 5%

2 PDAF-Kalibrierungsablauf

Die PDAF-Kalibrierung besteht aus zwei Teilen: Gain-Map-Kalibrierung und DCC-Map-Kalibrierung. Der Ablauf lautet:

Technische Abbildung aus der englischen Quelle, PDF S. 12.

2.1 Vorbereitung der Kalibrierung

1. Modulvorbereitung

(1) Prüfung auf Objektivverschmutzung

(2) VCM-Prüfung: Linearität, Genauigkeit und Stabilität der Linsenposition testen

(3) AF-Grundkorrektur:

Ermitteln Sie die Beziehung zwischen DAC und Fokusabstand: Kalibrieren Sie die Motorposition des Modulobjektivs bei Inf und Marco, zeichnen Sie die zugehörigen Werte DAC_inf und Dac_marco auf und bestimmen Sie DCC_LENS_BEGIN und DCC_LENS_END. Der Objektabstand, bei dem die Schärfe bei mittlerer Motorposition am größten ist, ist der DCC-Map-Kalibrierabstand a.

Die mittlere Motorposition ist DAC = (DAC_INF + DAC_MACRO)/2. Der entsprechende Kalibrierabstand a lässt sich aus der Schärfentiefentabelle des Objektivs bestimmen. Ermitteln Sie zuerst die Linsenverschiebungen für INF und MACRO, berechnen Sie die Mitte zwischen beiden und suchen Sie in der Tabelle die dieser Mitte nächstgelegene Linsenverschiebung. Daraus ergeben sich die mittlere Motorposition und der zugehörige Objektabstand A. Beispiel: Bei unendlichem Objektabstand beträgt die Linsenverschiebung 0. Als kürzester Objektabstand werden 10cm gewählt, mit einer Linsenverschiebung von -0.183. Die Linsenverschiebung in der mittleren Motorposition beträgt dann -0.0915. Der nächstgelegene Tabellenwert ist -0.091; der entsprechende DCC-Map-Kalibrierabstand a beträgt 0.20 Meter.

(4) Unterstützt das Modul OIS, muss vor der LSC- und PDAF-Kalibrierung die Verwacklungskorrektur abgeschlossen werden. Bewegen Sie den Motor zur XY-Referenzposition, um die OIS-Konfiguration zu überprüfen. Dieser Schritt erzeugt homogene Feldbilder für die LSC- und PDAF-Indexierung.

(5) Schließen Sie Schwarzpegel- und LSC-Korrektur ab. Falls erforderlich, kann die Bildfeldwölbung korrigiert werden.

1. AE-Einstellungen des Moduls

(1) AE-Einstellung des Moduls: Die digitale Verstärkung ist fest 1. Analoge Verstärkung: Bei traditionellem PD oder 2x1OCL wird again auf 1x gesetzt; bei Dual-Photodiode-PD auf 2x, um Pixel-Blooming zu vermeiden.

(2) Belichtungszeit: Um Ladungs-Blooming bei Dual-PD und Überbelichtung normaler Pixel (regular_pixel=dual_pd_l+dual_pd_r) zu vermeiden, passen Sie die Belichtungszeit so an, dass bei Darstellung in voller Größe die Helligkeit des G-Kanals im mittleren Bereich 700 (raw10) beträgt. Bei OCL- und Metal-Shield-Typen muss die G-Kanal-Helligkeit im Zentrum 800 (raw10) betragen. Für den Sensor wird eine Belichtungszeit als ganzzahliges Vielfaches von 10ms empfohlen, um Netzfrequenzstörungen zu vermeiden.

2.2 Gain-Map-Kalibrierung

1. Lichtumgebung und Ausrüstung

D50 (5000K±100K), unter Vermeidung von Störlicht aus der Umgebung.

Homogenisator oder DNP-Lichtbox entsprechend der obigen Lichtquelle; Ulbricht-Kugel.

1. Aufnahmeverfahren

Technische Abbildung aus der englischen Quelle, PDF S. 16.

1. Platzieren Sie das Modul vor der homogenen Flächenlichtquelle und halten Sie seine Stirnfläche parallel zur Lichtquellenfläche. Bei der im Versuch verwendeten Ulbricht-Kugel wird die Flächenhelligkeit beispielsweise auf 6.6 eingestellt. Platzieren Sie den Homogenisator vor dem Objektiv, damit die Flächenlichtquelle das Bild ausfüllt.
2. Sensorverstärkung: Bei Metal-Shield- und 2x1OCL-Sensoren again und dgain auf 1x setzen. Bei Dual-PD-Sensoren again auf 2x und dgain auf 1x setzen; die Belichtungszeit auf Vielfache von 10 einstellen.
3. Deaktivieren Sie Sensoreinstellungen wie mirro/flip/OB.
4. Bei Darstellung in voller Größe beträgt der Mittelwert der hellsten 10% des G-Kanals in der mittleren ROI von 1/32W*1/32H 800LSB (raw10) oder 200LSB (raw8). Der Mittelwert des Dual-PD-G-Kanals beträgt 700LSB (raw10) oder 175LSB (raw8).
5. Schalten Sie die Kamera ein und lassen Sie sie 3 Minuten aufwärmen. Bewegen Sie den Motor in die mittlere Position und nehmen Sie 3 RAW-Bilder nacheinander auf. Prüfen Sie zuerst, ob die Anzahl defekter Pixel den zulässigen Bereich überschreitet. Ist dies der Fall, verringern Sie die Bildhelligkeit und nehmen Sie erneut auf. Wird die Defektpixelprüfung bestanden, bilden Sie die gemittelten Bilddaten.

1. Kalibrierung

Der Aufruf von pdaf_gainmap_calibration (…) erzeugt die Gain-Map-Daten und liefert deren Größe: gainmap_width*gainmap_height *2 Bytes, einschließlich linker und rechter Gain Map.

1. Verifikation

1. Stellen Sie dieselbe Umgebung wie in Schritt 2 sicher und nehmen Sie ein Testbild auf. Übergeben Sie die kalibrierte Gain Map und das Testbild an pdaf_gainmap_vertification (…). Bei Rückgabe 1 ist die Verifikation erfolgreich und die kalibrierte Gain Map verwendbar. Bei Rückgabe -1 prüfen Sie, ob die Anzahl defekter Pixel den zulässigen Bereich überschreitet; verringern Sie die Bildhelligkeit und nehmen Sie erneut auf.

2. Verifikationskriterien

Beträgt der Unterschied zwischen dem durch die Gain Map korrigierten linken und rechten PD-Pixel weniger als 5%, ist die Verifikation erfolgreich.

2.3 DCC-Map-Kalibrierung

DCC (defocus conversion coefficient, Defokus-Umrechnungskoeffizient) beschreibt die Beziehung zwischen Motorposition und Unterschieden des linken und rechten Bildes. Das Bild wird in Bereiche aufgeteilt, der Motor in gleichen Schritten bewegt und der PD-Wert an verschiedenen Positionen berechnet. Durch lineare Regression werden die DCC-Werte der einzelnen Bereiche bestimmt: DCCMAP.

DCC = Δlensposition[dac]/Δphasedisparity[pixel]

Technische Abbildung aus der englischen Quelle, PDF S. 17.

[optional]

Bei manchen Modulen muss PD_OFFSET kalibriert werden. Beispielsweise ergibt sich bei der Motorposition DAC_0 ein unscharfes Fokusbild; die berechnete scharfe Fokusposition lautet DAC = DAC_0 + PD * DCC + PD_OFFSET * DCC.

1. Lichtumgebung und Ausrüstung

D50 (5000K±100K), unter Vermeidung von Störlicht aus der Umgebung.

Homogenisierungsfolie oder DNP-Lichtbox entsprechend der obigen Lichtquelle, Ulbricht-Kugel und Schwarz-Weiß-Referenztafel.

Referenztafel: Sie besteht aus einer individuell gefertigten lichtdurchlässigen Folie mit gleichmäßig angeordneten schwarzen und weißen Streifen oder einem Rautengitter.

Technische Abbildung aus der englischen Quelle, PDF S. 17.

Technische Abbildung aus der englischen Quelle, PDF S. 18.

Technische Abbildung aus der englischen Quelle, PDF S. 18.

Der Kalibrierabstand a wird im Schritt zur AF-Grundkorrektur 2.1.1 bestimmt.

Die Breite der Referenztafel hängt vom horizontalen FOV des Objektivs und vom Kalibrierabstand a ab. Empfohlen wird:

S >= a * tan(FOV * pi/360) * 2/0.9

Der Kalibrierabstand wird im Schritt zur AF-Grundkorrektur 2.1.1 bestimmt.

Die Breite der Referenztafel hängt vom horizontalen FOV des Objektivs und vom Kalibrierabstand a ab. Empfohlen wird:

λ[mm] = (u[um]/1000) * raw_width/(6 * dccmap_width)

W[mm] = (a[mm] - f[mm])/f[mm] * λ[mm]

Für IMX258 wird der Koeffizient λ=0.11 empfohlen, für S5KJN1 λ=0.088~0.099.

Die DCC-Kalibrierung verlangt eine korrekt angefertigte und platzierte Referenztafel. Ungeeignete Streifenbreiten, Verdrehung oder Verformung beim Aufstellen sowie zu geringe Helligkeit oder Überbelichtung führen zum Scheitern der DCC-Kalibrierung. Die folgende Abbildung zeigt einige Fehlerfälle.

Technische Abbildung aus der englischen Quelle, PDF S. 18.

1. Aufnahmeverfahren

1. Platzieren Sie die Streifenfolie vor der Ulbricht-Kugel und das Modul vor der Referenztafel ungefähr in der mittleren Fokusposition. Der Abstand wird durch die AF-Grundkorrektur in Schritt 2.1.1 bestimmt. Halten Sie die Stirnfläche parallel zur Referenztafel; vermeiden Sie Drehung, Neigung und Verwindung der Tafel. Das Muster muss bei der Aufnahme das gesamte Bild ausfüllen.
2. Sensorverstärkung: Bei Metal-Shield- und 2x1OCL-Sensoren again und dgain auf 1x setzen; bei Dual-PD-Sensoren again auf 2x und dgain auf 1x.
3. Deaktivieren Sie mirro/flip/OB und Defektpixelentfernung im Sensor.
4. Belichtung: Stellen Sie sicher, dass der Mittelwert des G-Kanals im weißen Block der mittleren ROI von 1/32w*1/32h auf der Referenztafel 800LSB (raw10) beziehungsweise 200LSB (raw8) beträgt. Der Mittelwert des Dual-PD-G-Kanals muss 700LSB (raw10) oder 175LSB (raw8) betragen, damit unzureichende Helligkeit oder Überbelichtung die DCC-Kalibrierungsgenauigkeit nicht beeinträchtigen. Bei Metal-Shield-Sensoren dürfen die nicht abgeschirmten Pixel nicht überbelichtet sein.
5. Bewegen Sie den Motor von DCC_LENS_BEGIN bis DCC_LENS_END in Schritten von DCC_LENS_INTERVAL. Nehmen Sie nach jeder Stabilisierung des Motors drei RAW-Bilder auf und bilden Sie die gemittelten Bilddaten für jede Position. Im Versuch wurde der Code beispielsweise von 0 bis 64 in Schritten von 8 verändert; dies ergab insgesamt 9 Positionen und 27 Bilder.

1. Kalibrierung

Übergeben Sie die in Abschnitt 2.1 kalibrierte Gain Map, die Motorpositionsparameter und die gemittelten Bilddaten jeder Position an pdaf_dccmap_calibration (…), um die DCC-Map-Daten und deren Größe zu erhalten.

Die Größe beträgt dccmap _width*dccmap _height *2 Bytes. Bei gewählter PD_OFFSET-Kalibrierung beträgt die Wertgröße ebenfalls 2bytes; die Quelle nennt hierbei DCC_RSQ_THRESHOLD. Überschreitet die Anzahl der Blöcke, die den Linearitätsschwellenwert nicht erfüllen, einen bestimmten Wert, schlägt die Kalibrierung fehl. Prüfen Sie dann die Eingabedaten, passen Sie die Kalibrierumgebung an und nehmen Sie erneut auf.

1. Verifikation

Dieser Schritt prüft, ob die aktuell kalibrierte DCC Map korrekt ist. Der Prüfablauf ist nachfolgend dargestellt:

Technische Abbildung aus der englischen Quelle, PDF S. 19.

1. Die Beleuchtungsumgebung der Prüfaufnahmen muss der DCC-Map-Kalibrierumgebung entsprechen. Die Objektivfläche ist parallel zur Referenztafel auszurichten, sodass deren Muster bei der Aufnahme das Bild vollständig ausfüllt.

2. Schalten Sie die Kamera ein und lassen Sie sie 3 Minuten aufwärmen. Stellen Sie den Motor auf eine Position DAC0 mit unscharfem Bild:

DAC0 ∈ (DACinf + 0.2 * abs(DACinf - DACmacro), DACinf + 0.8 * abs(DACinf - DACmacro)]

Nehmen Sie nach Stabilisierung des Motors drei RAW-Bilder auf und mitteln Sie die Bilddaten. Übergeben Sie die aktuelle Motorposition DAC0, die gemittelten Bilddaten sowie die kalibrierte Gain Map und DCC Map an pdaf_dccmap_vertification(). Die Funktion berechnet aus der unscharfen Aufnahme die ideale Fokusposition DAC1.

3. Bewegen Sie den Motor anschließend auf DAC1 und nehmen Sie fünf Bilder im Bereich tolerance_factor*abs(DACinf-DACmacro)+Δ (beispielsweise Δ=2) vor und hinter DAC1 auf. tolerance_factor bezeichnet den Toleranzbereich der Verifikation; der Fehlerbereich unterscheidet sich nach Sensortyp, beispielsweise 5%, 10% oder 20%.

Bewegen Sie den Motor während der Verifikation von Position 1 bis Position 5. Die fünf Positionen lauten beispielsweise für tolerance_factor=10% und Δ=2:

4.

5. Übergeben Sie die fünf Bilder an pdaf_calc_sharpness (…). Berechnen Sie die Schärfe im mittleren Bildbereich DCC_PERCENT_ROI_W* DCC_PERCENT_ROI_H, beispielsweise 30%*30%, und prüfen Sie, ob ein Maximum vorliegt. Ist dies der Fall, ist die Verifikation erfolgreich. Schlägt sie fehl, erweitern Sie den Bereich von tolerance_factor und Δ, etwa Δ von 2 auf 5, nehmen Sie erneut 5 Bilder auf und wiederholen Sie Schritt 4. Zur Schärfeberechnung sollte vorzugsweise ein Kanal mit wenigen PD-Pixeln gewählt werden.

Technische Abbildung aus der englischen Quelle, PDF S. 20.

3 Kalibrierungsverfahren

Zu den kalibrierten Modulen gehören AWB (automatischer Weißabgleich), LSC (Objektivabschattungskorrektur) und PDAF (Phasendetektions-Autofokus).

3.1 AWB-Kalibrierung

【Funktionsbeschreibung】

Diese Funktion berechnet R/G, B/G und Gr/Gb der ROI eines RAW-Bildes.

【Funktionsprototyp】

bool awb_otp_Calibrate(uint16_t* RawAddr, int width, int height, int roiw,
                       int roih, int bits, int bayer, int blc_r, int blc_gr,
                       int blc_gb, int blc_b, uint16_t* R, uint16_t* Gr,
                       uint16_t*Gb, uint16_t* B, uint16_t* R_G, uint16_t* B_G,
                       uint16_t* Gr_Gb)

【Eingabeinformationen】

【Ausgabeinformationen】

【Rückgabewert】

=0: Der Parameter ist fehlerhaft.

=1: Die Kalibrierung war erfolgreich.

3.2 LSC-Kalibrierung

3.2.1 LSC-Kalibrierung

【Funktionsbeschreibung】

Diese Funktion berechnet die Verstärkung jedes Kanals des RAW-Bildes.

【Funktionsprototypen】

bool lsc_otp_Calibrate(int vig,uint16_t* RawAddr, int width, int height,
                       int bits, int bayer, int blc_r, int blc_gr,
                       int blc_gb, int blc_b, float ratio, uint16_t* lsc_otp)

【Eingabeinformationen】

【Ausgabeinformationen】

【Rückgabewert】

=0: Die LSC-Kalibrierungsdaten und die Randabschattung sind fehlerhaft.

=1: Kalibrierung erfolgreich.

3.2.2 LSC-Verifikation

【Funktionsbeschreibung】

Diese Funktion prüft die Ergebnisse der LSC-Kalibrierung.

【Funktionsprototypen】

bool lsc_otp_verify(uint16_t *RawAddr, int width, int height, int bits,
                    int bayer, int blc_r, int blc_gr, int blc_gb,
                    int blc_b, uint16_t *lsc_otp, int Ydiffer_down,
                    int Ydiffer_up, int ColorShading_down,
                    int ColorShading_up, float *fYdiffer,
                    float *fRGCorner,float *fBGCorner)

【Eingabeinformationen】

【Ausgabeinformationen】

【Rückgabewert】

=0: Die Prüfkriterien nach der Kalibrierung werden nicht erfüllt; die Verifikation schlägt fehl.

=1: Verifikation erfolgreich.

3.3 PDAF-Kalibrierung

3.3.1 Sensorkonfiguration abrufen

【Funktionsbeschreibung】

Konfigurieren Sie sensor.ini und lesen Sie die Informationen zum PD-Sensor aus dieser Datei.

【Konfigurationsinhalt】

[sensor config]

Dual-Typ

[sensor config]

[Gainmap_Calib]

[DCCmap_Calib]

[optional params]

【Beispiel】

Als Beispiel dient die in der folgenden Abbildung gezeigte PD-Pixelverteilung des IMX258:

Technische Abbildung aus der englischen Quelle, PDF S. 30.

Entsprechend den Informationen in der Abbildung lautet der Inhalt von sensor.ini:

[sensor config]
RAW_WIDTH =4208
RAW_HEIGHT =3120
RAW_BITS =12
RAW_BLACK_LEVEL =64
RAW_BAYER_PATTERN =0
SENSOR_TYPE=0
PD_DUAL_MODE=0
PD_BINNING_TYPE=0
PD_OFFSET_X =24
PD_OFFSET_Y =24
PD_PITCH_X =32
PD_PITCH_Y =32
PD_DENSITY_X =16
PD_DENSITY_Y =16
PD_BLOCK_NUM_X =130
PD_BLOCK_NUM_Y =96
CALB_S_LEVEL=1000
CALB_S_CNT=10
PD_POS_L=
[26 29]
[42 29]
[33 48]
[49 48]; #end with a ";"
PD_POS_R=
[25 32]
[41 32]
[34 45]
[50 45]; #end with a ";"
[Gainmap_Calib]
GAINMAP_BLKSZ_W=16
GAINMAP_BLKSZ_H=16
GAIN_CALIB_INPUT_MAX=920
GAIN_CALIB_INPUT_MIN=800
GAIN_VERIFY_DIFF_MAX=5
CROSS_VER=1
[DCCmap_Calib]
DCCMAP_BLKSZ_W=32
DCCMAP_BLKSZ_H=32
DCC_CALIBRATE_MODE=1
DCC_LENS_BEGIN=0
DCC_LENS_END=64
DCC_LENS_INTERVAL=8
DCC_RSQ_THRESHOLD=0.985
DCC_BORDER_RSQ_THRESHOLD=0.97
DCC_BAD_RSQ_NUM_RATIO=0.05
DCC_CALIB_INPUT_MAX=640
DCC_CALIB_INPUT_MIN=340
DCC_VERIFY_CAF_DIFF_MAX=10
DCC_VERIFY_CAF_DIFF_DET=2
CALIB_TARGET_PEAK_OFFSET_LOG=0
CALIB_TARGET_PEAK_OFFSET=0
DCC_PERCENT_ROI_W=0.4
DCC_PERCENT_ROI_H=0.4
DCC_SHARPNESS_MODE=1
DCC_SHARPNESS_CHL=1
[optional params]
QUALITY_VERIFY_ENABLE=1
QUALTI_LRDiff_L_MIN=0.4
QUALTI_LRDiff_L_MAX=2.5
QUALTI_LRDiff_C_MIN=0.55
QUALTI_LRDiff_C_MAX=1.8
QUALTI_LRDiff_R_MIN=0.4
QUALTI_LRDiff_R_MAX=2.5
QUALITY_SENSITIVITY_MIN=0.45

【Funktionsprototypen】

bool pdaf_initial(char* filename, sensor_cfg* psensor_cfg)

【Eingabeinformationen】

【Ausgabeinformationen】

【Rückgabewert】

=0: sensor.ini konnte nicht gelesen werden.

=1: sensor.ini erfolgreich gelesen.

3.3.2 Gain-Map-Kalibrierung

【Funktionsbeschreibung】

Diese Funktion dient der Kalibrierung von PDAF-Gain-Maps.

【Funktionsprototypen】

bool pdaf_gainmap_calibration(uint16_t *RawAddr, sensor_cfg* psensor_cfg,
                              uint16_t *gainmap_lut,int* gainmap_width,
                              int* gainmap_height)

【Eingabeinformationen】

【Ausgabeinformationen】

【Rückgabewert】

=0: Der Parameter ist fehlerhaft.

=1: Kalibrierung erfolgreich.

3.3.3 Gain-Map-Verifikation

【Funktionsbeschreibung】

Diese Funktion prüft, ob die kalibrierte Gain Map die Anforderungen erfüllt.

【Funktionsprototypen】

bool pdaf_gainmap_vertification(uint16_t *RawAddr, sensor_cfg* psensor_cfg,
                                uint16_t *gainmap_lut)

【Eingabeinformationen】

【Rückgabewert】

=0: Die Verifikation ist fehlgeschlagen; die dafür verwendete Gain Map erfüllt die Anforderungen nicht.

=1: Verifikation erfolgreich.

3.3.4 DCC-Map-Kalibrierung

【Funktionsbeschreibung】

Diese Funktion dient der Kalibrierung der PDAF-DCC-Map.

【Funktionsprototypen】

bool pdaf_dccmap_calibration(uint16_t *RawAddrAll , sensor_cfg* psensor_cfg,
                             uint16_t *gainmap_lut, uint16_t *dccmap_lut,
                             int* dccmap_width,int* dccmap_height,
                             uint8_t* dccSign,wchar_t*pd_offset)

【Eingabeinformationen】

【Ausgabeinformationen】

【Rückgabewert】

=0: Kalibrierung fehlgeschlagen.

=1: Kalibrierung erfolgreich.

3.3.5 DCC-Map-Verifikation

Prüft, ob die kalibrierte DCC Map die Anforderungen erfüllt. Dazu dienen die beiden Funktionsschnittstellen pdaf_dccmap_vertification() und pdaf_calc_sharpness().

【Funktionsbeschreibung】

Ermittelt anhand der kalibrierten DCC Map die ideale scharfe Fokusposition DAC1 des unscharfen Bildes.

【Funktionsprototyp】

uint16_t pdaf_dccmap_vertification(uint16_t *RawAddr, sensor_cfg* psensor_cfg,
                                   int cur_pos_id, uint16_t *gainmap_lut,
                                   uint16_t *dccmap_lut, uint8_t dccSign, wchar_t
*pd_offset)

【Eingabeinformationen】

【Rückgabewert】

Motorposition DAC1, bei der das unscharfe Bild ideal fokussiert ist.

【Funktionsbeschreibung】

Berechnet die Schärfe des mittleren Bildbereichs innerhalb von DCC_VERIFY_CAF_DIFF_MAX*abs (DACinf- DACmacro)+DCC_VERIFY_CAF_DIFF_DET vor und hinter DAC1, um festzustellen, ob ein Maximum vorliegt.

【Funktionsprototyp】

bool pdaf_calc_sharpness(uint16_t *RawAddrAll, int img_num, sensor_cfg*
psensor_cfg)

【Eingabeinformationen】

【Rückgabewert】

=0: Kein Schärfemaximum gefunden; Verifikation fehlgeschlagen.

=1: Verifikation erfolgreich.

4 Anhang

4.1 Beispielcode zur OTP-Anwendung

#include <iostream>
#include "RKOTPDLL.h"
#include <stdlib.h>
int main()
{
    int ret = 0;
    #LSC AWB Otp Calibration
    ret =lsc_awbtest();
    #Pdaf Otp Calibration
    uint16_t gainmap[30*30 * 2];
    uint16_t dccmap[20 * 20 * 2];
    uint16_t code = 0;
    int gainmap_width = 0;
    int gainmap_height = 0;
    int dccmap_width = 0;
    int dccmap_height = 0;
    uint8_t dcc_Sign = 0;
    wchar_t pd_offset=0xffff;
    int curpos = 864;
    sensor_cfg sensor_param;
    if (pdaf_initial("D:\\testdll\\testdll\\sensor_ov16A10.ini", &sensor_param))
    {
        if (gainmaptest(&sensor_param, gainmap,&gainmap_width,&gainmap_height))
        {
        if (dccmaptest(&sensor_param, gainmap, dccmap, curpos, &code,
&dccmap_width, &dccmap_height, &dcc_Sign,&pd_offset))
            {
                ret = dcc_calc_sharpness(&sensor_param);
            }
        }
    }
}
bool lsc_awbtest()
{
    int vig=70;
    int height = 1944;
    int width = 2592;
    int bits =10;#10bit
    int bayer =0;#BGGR
    int roiw =5;#1/5 width
    int roih =5;#1/5 height
    int blc[4]={ 64, 64, 64, 64};
    uint16_t lsctable[17*17*4];
    uint16_t awb[3];
    uint16_t Rave =0;
    uint16_t Grave =0;
    uint16_t Gbave =0;
    uint16_t Bave =0;
    int Ydiffer_down =0;#%
    int Ydiffer_up =5;#%
    int ColorShading_down =0;#%
    int ColorShading_up =5;#%
    float Ydiffer = 0;
    float RGconer[25];
    float BGconer[25];
    bool ret =0;
    uint16_t *Rawdata = NULL;
    Rawdata = (uint16_t*)malloc(width * height * 2);
    memset(Rawdata, 0, sizeof(uint16_t)* width * height);
    FILE *fp = NULL;
    fp = fopen("input.raw", "rb");
    if (fp == NULL)
    {
        return false;
    }
    fread(Rawdata, 1, height * width * 2, fp);
    fclose(fp);
    ret =lsc_otp_Calibrate(vig,Rawdata, width, height, bits, bayer, blc[0],
blc[1],blc[2], blc[3],lsctable);
    ret = awb_otp_Calibrate(Rawdata, width, height,roiw,roih, bits, bayer,
blc[0], blc[1],blc[2], blc[3],&Rave,&Grave,&Gbave,&Bave, &awb[0], &awb[1],
&awb[2]);
    ret = lsc_otp_verify(Rawdata, width, height, bits, bayer, blc[0], blc[1],
blc[2], blc[3], lsctable, Ydiffer_down, Ydiffer_up, ColorShading_down,
ColorShading_up, &Ydiffer, RGconer, BGconer);
    if(!ret)
    {
        return false; #The calibrated data does not meet the control standards and the verification fails.
    }
    if(Rawdata!=NULL)
    {
        free (Rawdata);
        Rawdata =NULL;
    }
    return ret;
}
int gainmaptest(sensor_cfg* psensor_cfg, uint16_t *gainmap_lut,int *
gainmap_width, int *gainmap_height)
{
    int ret = 0;
    int height = psensor_cfg->height;
    int width = psensor_cfg->width;
    uint16_t maxval = (1 << psensor_cfg->bits) - 1;
    int gainmapfilenum = 3;
    int over_exp_cnt = 0;
    if (psensor_cfg->pd_dual_mode && psensor_cfg->mipi_mix_mode)
    {
        height = psensor_cfg->height + (psensor_cfg->sensor_type+1)*psensor_cfg->pd_height;
    }
    uint16_t *ave_pixelbuf = NULL;
    ave_pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(ave_pixelbuf, 0, sizeof(uint16_t)* width * height);
    uint16_t *sum_pixelbuf = NULL;
    sum_pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(sum_pixelbuf, 0, sizeof(uint16_t)* width * height);
    uint16_t *pixelbuf = NULL;
    pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(pixelbuf, 0, sizeof(uint16_t)* width * height);
    FILE *fp = NULL;
    char prename[20] = "gainRAW";
    char endname[5] = ".raw";
    for (int i = 0; i < gainmapfilenum; i++)
    {
        char temp[20];
        char id[5];
        int idint = i + 1;
        strcpy(temp, prename);
        _itoa_s(idint, id, 10);
        strcat(temp, id);
        strcat(temp, endname);
        fp = fopen(temp, "rb");
        if (fp == NULL)
        {
            return false;
        }
        fread(pixelbuf, 1, height * width * 2, fp);
        fclose(fp);
        for (int j = 0; j < height; j++)
        {
            for (int i = 0; i < width; i++)
            {
                uint32_t tempbuf = *(pixelbuf + j*width + i);
                *(sum_pixelbuf + j*width + i) = tempbuf + *(sum_pixelbuf +
j*width + i);
                if (tempbuf >= maxval)
                    over_exp_cnt++;
            }
        }
    }
    for (int j = 0; j < height; j++)
    {
        for (int i = 0; i < width; i++)
        {
            *(ave_pixelbuf + j*width + i) = *(sum_pixelbuf + j*width + i) /
gainmapfilenum;
        }
    }
    ret = pdaf_gainmap_calibration(ave_pixelbuf, psensor_cfg, gainmap_lut,
gainmap_width,gainmap_height);
    ret = pdaf_gainmap_vertification(ave_pixelbuf, psensor_cfg, gainmap_lut);
    if(ret == -1)
        printf("gainmap image OVER exposure!!!");
    if (ave_pixelbuf!=NULL)
    {
        free(ave_pixelbuf);
        ave_pixelbuf = NULL;
    }
    if (pixelbuf != NULL)
    {
        free(pixelbuf);
        pixelbuf = NULL;
    }
    if (sum_pixelbuf != NULL)
    {
        free(sum_pixelbuf);
        sum_pixelbuf = NULL;
    }
    return ret;
}
bool dccmaptest(sensor_cfg* psensor_cfg, uint16_t *gainmap_lut, uint16_t
*dccmap_lut, int curpos , uint16_t *code, int *dccmap_width, int *dccmap_height,
uint8_t *dcc_Sign,wchar_t *pdaf_offset)
{
    int ret = 0;
    int lens_begin = 0;
    int lens_end = 64;
    int lens_interval = 8;
    int height = psensor_cfg->height;
    int width = psensor_cfg->width;
    int lensnum = (lens_end - lens_begin) / lens_interval + 1;
    if (psensor_cfg->pd_dual_mode && psensor_cfg->mipi_mix_mode)
    {
        height = psensor_cfg->height + (psensor_cfg->sensor_type +
1)*psensor_cfg->pd_height;
    }
    uint16_t *ave_pixelbuf = NULL;
    ave_pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(ave_pixelbuf, 0, sizeof(uint16_t)* width * height);
    uint16_t *Rawdata = NULL;
    Rawdata = (uint16_t*)malloc(width * height * 2 * lensnum);
    memset(Rawdata, 0, sizeof(uint16_t)* width * height* lensnum);
    uint16_t *pixelbuf= NULL;
    pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(pixelbuf, 0, sizeof(uint16_t)* width * height);
    FILE *fp = NULL;
    char prename[20] = "dccRAW";
    char endname[5] = ".raw";
    for (int a = 0;a <lensnum;a++)
    {
        char temp[20];
        char id[5] ;
        int id1 = a + 1;
        strcpy(temp,prename);
        _itoa_s(id1, id, 10);
        strcat(temp, id);
        for (int b = 0; b < 3;b++)
        {
            char name[20];
            strcpy(name, temp);
            int id2 = b + 1;
            _itoa_s(id2, id, 10);
            strcat(name, id);
            strcat(name, endname);
            fp = fopen(name, "rb");
            if (fp == NULL)
            {
                return false;
            }
            fread(pixelbuf, 1, height * width * 2, fp);
            fclose(fp);
            for (int j = 0; j < height; j++)
            {
                for (int i = 0; i < width; i++)
                {
                    uint16_t tempbuf = *(ave_pixelbuf + j*width + i);
                    *(ave_pixelbuf + j*width + i) = tempbuf + *(pixelbuf +
j*width + i) / 3;
                }
            }
        }
        memcpy(Rawdata + a*height * width, ave_pixelbuf, sizeof(uint16_t)*height
* width);
        memset(ave_pixelbuf, 0, sizeof(uint16_t)* width * height);
    }
    ret = pdaf_dccmap_calibration(Rawdata, psensor_cfg, gainmap_lut, dccmap_lut,
dccmap_width, dccmap_height, dcc_Sign,pd_offset);
    memset(pixelbuf, 0, sizeof(uint16_t)* width * height);
    memset(ave_pixelbuf, 0, sizeof(uint16_t)* width * height);
    char prename1[20] = "image";
    for (int i = 0; i < 3; i++)
    {
        char temp[20];
        char id[5];
        int idint = i + 1;
        strcpy(temp, prename1);
        _itoa_s(idint, id, 10);
        strcat(temp, id);
        strcat(temp, endname);
        fp = fopen(temp, "rb");
        if (fp == NULL)
        {
            return false;
        }
        fread(pixelbuf, 1, height * width * 2, fp);
        fclose(fp);
        for (int j = 0; j < height; j++)
        {
            for (int i = 0; i < width; i++)
            {
                uint16_t tempbuf = *(ave_pixelbuf + j*width + i);
                *(ave_pixelbuf + j*width + i) = tempbuf + *(pixelbuf + j*width +
i) / 3;
            }
        }
    }
        *code = pdaf_dccmap_vertification(ave_pixelbuf, psensor_cfg, curpos,
gainmap_lut, dccmap_lut, *dcc_Sign,pd_offset);
    if (ave_pixelbuf != NULL)
    {
        free(ave_pixelbuf);
        ave_pixelbuf = NULL;
    }
    if (pixelbuf != NULL)
    {
        free(pixelbuf);
        pixelbuf = NULL;
    }
    if (Rawdata != NULL)
    {
        free(Rawdata);
        Rawdata = NULL;
    }
    return ret;
}
bool dcc_calc_sharpness(sensor_cfg* psensor_cfg)
{
    int height = psensor_cfg->height;
    int width = psensor_cfg->width;
    int imgnum = 5;
    if (psensor_cfg->pd_dual_mode && psensor_cfg->mipi_mix_mode)
    {
        height = psensor_cfg->height + (psensor_cfg->sensor_type +
1)*psensor_cfg->pd_height;
    }
    uint16_t *Rawdata = NULL;
    Rawdata = (uint16_t*)malloc(width * height * 2 * imgnum);
    memset(Rawdata, 0, sizeof(uint16_t)* width * height* imgnum);
    uint16_t *pixelbuf = NULL;
    pixelbuf = (uint16_t*)malloc(width * height * 2);
    memset(pixelbuf, 0, sizeof(uint16_t)* width * height);
    FILE *fp = NULL;
    char prename[20] = "calimage";
    char endname[5] = ".raw";
    for (int i = 0; i < imgnum; i++)
    {
        char temp[20];
        char id[5];
        int idint = i + 1;
        strcpy(temp, prename);
        _itoa_s(idint, id, 10);
        strcat(temp, id);
        strcat(temp, endname);
        fp = fopen(temp, "rb");
        if (fp == NULL)
        {
            return false;
        }
        fread(pixelbuf, 1, height * width * 2, fp);
        fclose(fp);
        memcpy(Rawdata + i*height * width, pixelbuf, sizeof(uint16_t)*height *
width);
    }
    bool ret=pdaf_calc_sharpness(Rawdata, imgnum, psensor_cfg);
    if (pixelbuf != NULL)
    {
        free(pixelbuf);
        pixelbuf = NULL;
    }
    if (Rawdata != NULL)
    {
        free(Rawdata);
        Rawdata = NULL;
    }
    return ret;
}

4.2 Format der paketierten Programmierdaten

Wie in der folgenden Tabelle dargestellt, können Benutzer je nach Bedarf bestimmte Blöcke programmieren. Die Block-ID darf dabei nicht geändert werden. Nach dem Programmieren der benötigten Blöcke muss abschließend 0xff programmiert werden:

Die konkreten Blockinhalte folgen. Mehrbyte-Daten verwenden einheitlich Big-Endian: Das höherwertige Byte wird an der niedrigeren Adresse gespeichert, das niederwertige an der höheren: