Skip to content

Apple's open-source XNU kernel on Android phones: its own loader and drivers, Metal on the Adreno. Runs from RAM; a reboot gives the phone back to Android.

C

Camera ISP: full-size bilinear demosaic, colour matrix, lens-shading grid, rounded NV12

vcvkk9a58f106ee27
diff --git a/README.md b/README.md
index 2b61a33..bcd9e6c 100644
--- a/README.md
+++ b/README.md
@@ -287,7 +287,7 @@ XL_SECS=900 XL_CMDLINE="touchscreen=1 cpufreq=1 bootcpu=7 cpus=8" ./xl run #
| `sound=N` | с `adsp=1`, шаг 3 звука, путь к динамикам, как его строит Android (числа — из живого дерева устройств телефона, его путей микшера и его ядра): `sound=1` — ножки TDM (GPIO 97–100) отданы интерфейсу, звуковой процессор включает его тактовую частоту (3,072 МГц), группу и порт 0x9000 (PRI_TDM_RX_0) и запускает его; по ножкам видно, что тактовый сигнал и синхронизация кадров идут. `sound=2` — ещё и поток: наша память видна процессору через SMMU (поток 0x1801), путь ADM к порту, поток ASM, и в него 3 с пишется тон 1 кГц −20 дБ полной шкалы; процессор забирает его с частотой 48 кГц. Усилители выключены. `sound=3` — ещё и усилители: настраиваются из профиля «Music» конфигурации Android (`/vendor/etc/aw882xx_acf.bin` телефона в `fw-audio/`, в git не попадает, `userland/build.sh` кладёт её в `/fw` образа системы), каждая запись читается обратно, при любом расхождении или сбое оба сразу выключаются; громкость плавно поднимается до `sound_below` восьмых долей дБ ниже уровня Android (по умолчанию 240, то есть на 30 дБ тише; выше уровня Android — никогда), тон звучит 3 с, потом всё затихает, выключается и возвращается как было. `sound=4` — то, что играет iOS (`/dev/redwood-audio`), до конца сеанса: порт и поток работают всё время (без звука в них идёт тишина), усилители настраиваются один раз и выключены, а когда в записи iOS появляется не тишина, включаются и быстро (как у драйвера Android) выводятся на `sound_below`; после трёх секунд тишины снова выключаются. Звук доходит до усилителей через 160 мс после записи, усилители готовы через 65 мс. У динамика в модуле HAL есть регулятор громкости, его значение уходит в ядро (`ioctl` `REDWOOD_AUDIO_SET_VOLUME`) и задаёт уровень усилителей ниже потолка (0 — усилители не включаются), но iOS ставит его только раз, на максимум, а громкость кнопок и Пункта управления применяет к самим отсчётам (программная громкость для динамика iPhone X в таблицах VirtualAudio); при громкости 0 iOS пишет тишину, и усилители тоже не включаются. Проверка — `RC_JOBS=rc.jobs.volume`. По пути к усилителям — сторож (см. выше): `sound_gain=N` (восьмые доли дБ, 0–96), `sound_guard_as=N` (для проверки: сторож считает усилители на N ниже уровня Android и сдерживает, как сдерживал бы там). `sound_secs=S` (не больше 3 с тоном), `sound_pause=MS`. Подробности в начале `bsd/dev/redwood_sound.c` и `bsd/dev/redwood_speaker.c` |
| `haptic=N` | моторчик вибрации: Awinic AW86927 на I2C (шина QUP SE9, GPIO 36/37, адрес 0x5a; сброс — GPIO 35), линейный мотор с резонансом 175,5 Гц; всё — из живого дерева устройств Android, его журнала и регистров (`bsd/dev/redwood_haptic.c`). `haptic=1` — только читать: из загрузчика Android сброс держит чип выключенным, он не отвечает. `haptic=2` — сброс отпущен, как это делает драйвер Android, регистры прочитаны и сравнены с Android. `haptic=3` — ещё и настройка Android (каждая запись читается обратно; аналоговые регистры — за разблокировкой 0x5b) и волновые формы Android (`/vendor/firmware/aw8697_haptic.bin` телефона в `fw-haptic/`, в git не попадает; `userland/build.sh` кладёт его в `fw/` малого образа) в ОЗУ чипа, с проверкой чтением. `haptic=4` — ещё и одна короткая форма (`haptic_effect=1…10`) один раз, с усилением Android. `haptic=5` — моторчик для iOS до конца сеанса: всё, что iOS играет на своём устройстве «Actuator» (системные отклики и вибрация звонка, CoreHaptics приложений, отклики UIKit — например, меню иконки по долгому нажатию), звуковой модуль HAL отдаёт в `/dev/redwood-haptic`, и ядро играет по нему формы Android: каждую волну iOS — коротким толчком (форма 1), а длинную — повтором формы 11, пока iOS играет, но не дольше 1 с, после чего мотор столько же отдыхает; усиление — по громкости волны iOS: от трети полной шкалы и выше — усиление Android (0x80), ниже — до пяти восьмых его у самых тихих, и никогда не выше Android (волны iOS для Taptic Engine почти всегда гораздо тише полной шкалы, и в прямой пропорции большинство откликов выходило на десятой доле усиления Android — их было не почувствовать). Проверка обычных касаний: `RC_JOBS=rc.jobs.haptic2` (долгое нажатие на иконку, переключатель в Настройках). Без `haptic=5` iOS играет на «Actuator» как обычно, но в мотор ничего не идёт. Проверка: `RC_JOBS=rc.jobs.haptic`. Любая неисправность, о которой говорит чип, несовпадение при чтении или неотвеченный байт — чип снова в сброс до конца сеанса; не дольше 1 с на эффект; в конце сеанса и при панике — сброс |
| `torch=N` | фонарик: светодиодный модуль вспышки PM8350C (SPMI, ведомый 2, регистры 0xee00; задний светодиод — канал 0), значения Android: его фонарик горит на 125 мА через канал 0 (прочитано у включённого фонарика Android), шаг тока 12,5 мА, порядок записей — драйвера Xiaomi `leds-qti-flash.c` (`bsd/dev/redwood_torch.c`). `torch=1` — только читать: канал арбитра, тип модуля, регистры, температурная тревога PMIC. `torch=2` — ещё и зажечь один раз на 125 мА на `torch_secs` (по умолчанию 2 с). `torch=3` — фонарик для iOS: `/dev/redwood-torch` принимает уровень 0…1000 (тысячные тока Android, не выше 125 мА); загрузчик с `torch=N` добавляет в дерево `/product/camera` со свойством `flash` айфона (кнопка фонарика в Пункте управления), а `libredwood-media.dylib` отдаёт FigFlashlight в mediaserverd своё «устройство» вместо отсутствующей камеры (`userland/src/inject_media.c`). Пределы: записи — только в шесть регистров этого модуля, каждая читается обратно, канал арбитра перепроверяется; не дольше `torch_max_s` подряд (по умолчанию 30 с, не больше 120), потом темно, пока iOS не попросит снова; 10 раз в секунду — флаги неисправности и перегрева модуля, температурная тревога PMIC и температура батареи (не выше 45 °C; из battmgr при `adsp=1` или из `battery=1`) — что-то не так, и фонарик гаснет до конца сеанса; в конце сеанса и при панике — погашен. Проверка: `RC_JOBS=rc.jobs.torch` (`torch_test` — как программа, через AVFlashlight; потом кнопка в Пункте управления) |
-| `cam=N` | камеры: все четыре — макро, широкая, фронтальная и сверхширокая (`cam_sensor=macro|wide|front|ultra`, по умолчанию — макро, при `cam=5` — широкая); макрокамера — OmniVision OV02B10 (2 Мп, камера 2 Android, «redwood_aac_ov02b10_macro»); всё — из живого дерева устройств (cam-sensor2), файла модуля камеры Android (`/vendor/lib64/camera/com.qti.sensormodule.redwood_aac_ov02b10_macro.bin`: адрес, где и как читается ID чипа, порядок включения) и драйверов ядра Android (`bsd/dev/redwood_camera.c`). Датчик — на CCI 1, ведущий 0 (GPIO 73/74, здесь I2C вручную, как у других драйверов), адрес 0x3c; сброс — GPIO 77; MCLK — mclk2 camcc на 19,2 МГц на GPIO 66 (у Android эти 19,2 МГц — от PLL2 camcc, здесь — от самого кварца, без PLL); питание — LDO6 (1,8 В, DOVDD) и LDO7 (2,8 В, AVDD) PM8008i, который на I2C последовательного движка 1 (GPIO 4/5, адреса 0x08 и 0x09) и выходит из сброса по GPIO 3 PM8350C, как его выводит Android. `cam=1` — только смотреть: тактовые частоты и домен питания камеры, ножки, сброс PM8008i и, если он не в сбросе, сам PM8008i. `cam=2` — ещё и включить датчик в порядке файла модуля (у макрокамеры: сброс низкий, 1 мс; DOVDD; AVDD, 2 мс; верхний домен питания камеры и MCLK, 4 мс; сброс высокий, 9 мс), прочитать ID чипа так, как читает Android (16-битный регистр по 16-битному адресу 0x0203; ждёт 0x002b), и выключить в обратном порядке. Пределы: напряжения — только Android (1,8 и 2,8 В у макрокамеры, 1,0 и 1,8 В у широкой), записи — только в перечисленные регистры (у каждого устройства — список, проверяется при каждой записи), каждая читается обратно; неотвеченный байт, регулятор не готов вовремя или сообщает о перегрузке по току, запись не читается обратно — всё выключается и больше ничего не пишется; в конце сеанса и при панике включённое выключается, найденное включённым остаётся включённым. `cam_after=S` — через сколько секунд после старта (по умолчанию 20). `cam=3` — путь кадра без датчика: генератор тестовой картинки CSID-lite 0 (RAW10 1600×1200, цветные полосы) → его путь RDI 0 → IFE-lite 0, чей мастер записи 0 пишет кадр в память через SMMU (поток 0x800, маска 0x4e0, в свободный контекст с нашими таблицами); для этого — голоса RPMh за CX на SVS и MX на SVS_L1 (через вторую TCS DRV 2, в конце отдаются), PLL0 camcc (1,2 ГГц), RCG и ветви камеры на частотах уровня «svs» из дерева устройств (cphy_rx, CSID, IFE-lite — 400 МГц, таймер PHY — 300, camnoc — 150, slow_ahb — 80), всё — по драйверам Android (`camcc-yupik.c`, `cam_ife_csid_lite17x.h`, `cam_vfe_lite16x.h`, `cam_vfe_bus_ver2.c`). `cam=4` — кадры самого датчика: питание и ID, как при `cam=2`, его таблицы Android — инициализация (108 записей), режим (1600×1200 RAW10, одна линия, 665,6 Мбит/с, 30 кадров/с), «пуск», таблица экспозиции; CSIPHY 2 (v1.2.1, D-PHY, линия данных 0 и линия такта; число отсчётов установления — из файла модуля для этого режима, 20, `cam_settle=N` — своё), приёмник CSID-lite 0 от PHY 2 и тот же путь RDI 0 → IFE-lite 0 → SMMU → память; несколько кадров подряд в два места, последний остаётся; потом «стоп» и всё выключается. Таблицы читаются при запуске из `fw/camera-ov02b10.tab` малого образа: его делает `tools/camsensor.py` из файла модуля датчика Android (`fw-camera/com.qti.sensormodule.redwood_aac_ov02b10_macro.bin` с телефона; ни он, ни таблицы в git не попадают). `cam_pattern=1` — тестовые полосы самого датчика вместо изображения, `cam_frames=N` — сколько кадров (по умолчанию 8), `cam_shutter=СТРОК`, `cam_gain=N` — своя экспозиция и усиление. Память с кадрами загрузчик отдаёт после сеанса: `./xl camera [префикс]` забирает её и через `tools/camraw.py` делает картинки (`префикс-N.png` — по пикселю на ячейку 2×2 Байера, серый мир, гамма 2,2; `префикс-N-raw.png` — сырые значения; порядок Байера изображения датчика — RGGB: в снимке комнаты друг за другом следуют второй и третий отсчёты ячейки, то есть зелёные; его собственные полосы приходят со сдвигом на строку, как GBRG; `--bayer N` — другой порядок; `cam_vblank=СТРОК` — удлинить кадр для выдержки длиннее 1200 строк). `cam_sensor=wide` — то же для основной широкоугольной камеры, Samsung S5KHM2SD (108 Мп, камера 0 Android, «redwood_sunny_s5khm2sd_wide», cam-sensor0): CCI 0, ведущий 1 (GPIO 71/72), адрес 0x20, ID чипа 0xfad2 по адресу 0x0000; сброс — GPIO 21; MCLK — mclk1 camcc (19,2 МГц, GPIO 65); питание — LDO1 (1,0 В, VDIG) и LDO5 (1,8 В, VIO) PM8008i и VANA 2,8 В от постоянного регулятора, который включает GPIO 106 (всё — напряжения дерева устройств); порядок включения и выключения, ID, таблицы и режимы — из её файла модуля (`fw-camera/com.qti.sensormodule.redwood_sunny_s5khm2sd_wide.bin` → `fw/camera-s5khm2sd.tab`, формат RWCTAB02 — все режимы, порядок питания, назначение линий; инициализация — 1441 запись; шесть режимов, от 12000×9000 до 1920×1080 на 240 кадрах/с). Кадры — по трём трио C-PHY в CSIPHY 1 (трёхфазные таблицы v1.2.1 Android и строка таблицы скоростей, покрывающая скорость трио; число отсчётов установления — из файла модуля, 34), CSID-lite 0 — в режиме C-PHY. `cam_mode=N` — режим из таблицы датчика (по умолчанию — с наименьшим числом пикселей: у широкой — 1920×1080 RAW10 на 120 кадрах/с, 3,11 Гбит/с на трио). Порядок Байера широкой — GBRG (в снимке комнаты друг за другом следуют первый и четвёртый отсчёты; красный против синего — по сырым уровням обеих камер при одном тёплом свете), заголовок кадра говорит его сам. Экспозиция широкой — регистры SMIA внутри group hold 0x0104: `cam_vblank` — длина кадра 0x0340, `cam_shutter` — выдержка 0x0202, `cam_gain` — аналоговое усиление 0x0204 (32 — 1×). `cam_sensor=front` — фронтальная камера, OmniVision OV16A1Q (16 Мп, cam-sensor1, «redwood_aac_ov16a1q_front»): CCI 0, ведущий 0 (GPIO 69/70), адрес 0x10, ID чипа 0x1641 по адресу 0x300b; сброс — GPIO 20; MCLK — mclk0 (19,2 МГц, GPIO 64); питание — LDO3 (2,8 В, VANA), LDO2 (1,2 В, VDIG), LDO5 (1,8 В, VIO) PM8008i; четыре линии D-PHY в CSIPHY 0 (по умолчанию — режим 1920×1080 на 120 кадрах/с, 1,44 Гбит/с на линию). `cam_sensor=ultra` — сверхширокая, Samsung S5K4H7 (8 Мп, cam-sensor3, «redwood_sunny_s5k4h7_ultra»): CCI 1, ведущий 1 (GPIO 75/76), адрес 0x2d, ID чипа 0x487b по адресу 0; сброс — GPIO 78; MCLK — mclk3 на 24 МГц, как просит её файл модуля: от PLL2 camcc (Zonda, 1440 МГц, настройки `cam_cc_pll2_config` Android, запуск — как `clk_zonda_pll_enable()`), делитель 10 и M/N 1/6 (`ftbl_cam_cc_mclk0_clk_src`); питание — LDO4 (2,8 В, VANA), LDO5 (1,8 В, VIO) и VDIG 1,2 В от постоянного регулятора (`camera_ultra_dvdd_ldo`, от PM7325 S8), который включает GPIO 108; четыре линии D-PHY в CSIPHY 3. Собственных цветных полос (таблицы «tpgon» в файле модуля) нет ни у широкой, ни у фронтальной, ни у сверхширокой — только у макрокамеры; `cam_pattern=1` для остальных даёт их изображение (при `cam=4`) или полосы CSID (при `cam=5`). Выдержка по `cam_shutter`/`cam_gain`/`cam_vblank` при `cam=4` — только у макро и широкой; фронтальная и сверхширокая при `cam=4` снимают с выдержкой своих таблиц. Порядок Байера: макро и фронтальная — RGGB, широкая и сверхширокая — GBRG (зелёные — два равных по уровню отсчёта ячейки; красный против синего — по отношениям R/G и B/G, одинаковым у всех четырёх при одном свете). Память под два кадра `cam=3`/`cam=4` (до 12 МБ каждый) берётся одним куском при загрузке (`cam_keep_mb`). `cam=5` — широкая камера для iOS: устройство `/dev/redwood-camera` (`bsd/sys/redwood_camera.h`); первое чтение после открытия включает датчик и запускает кадры (режим — `cam_mode`, по умолчанию 1: 4000×3000 RAW10, 30 кадров/с), последнее закрытие, секунда без чтения или любая неисправность всё выключают (после неисправности — до конца сеанса). Кадры идут по кругу в три места памяти ядра (отображённые через SMMU постранично): одно пишет IFE, одно может копировать чтение, одно готово; в каждом начале кадра адрес места для следующего кадра уходит мастеру записи, который берёт его в следующем начале кадра (на это есть целый кадр, а не промежуток между кадрами); кадр, для которого адреса не оказалось, считается переписанным. Строка RAW10 у мастера записи выровнена на 16 байт (4000 пикселей — 5008 байт, а не 5000). `read()` отдаёт заголовок (номер, время, выдержка, усиление, длина кадра и строки) и сам кадр; `write()` принимает другой датчик (`REDWOOD_CAMERA_SENSOR`: кадры останавливаются, всё выключается, следующее чтение включает другой; номер датчика — в заголовке кадра; режим по умолчанию — самый крупный 4:3 не быстрее 30 кадров/с и не больше 13 Мп: широкая 4000×3000, фронтальная 2304×1728, сверхширокая 3264×2448, макро 1600×1200; выдержка из `write()` пишется каждому его способом в его group hold: SMIA у широкой и сверхширокой — 0x0340/0x0202/0x0204, у фронтальной OV16A1Q — 0x380e/0x380f, 0x3500…0x3502, 0x3508/0x3509 (0x100 — 1×), у макро OV02B10 — страница 1: 0x14/0x15, 0x0e/0x0f, 0x22 (16 — 1×); предел усиления — свой у каждого: 64× у широкой, 16× у сверхширокой, 15,5× у фронтальной и макро), выдержку и усиление (пишутся между кадрами в group hold, с пределами: усиление от 1× до предела датчика, кадр не длиннее 0xfff0 строк) или картинку для хоста (память под неё — `cam_keep_mb`, по умолчанию 24, берётся при загрузке одним куском; `./xl camera` её забирает, `tools/camraw.py` понимает NV12 и BGRA). Проверка всех четырёх по очереди — `RC_JOBS=rc.jobs.cameras` (`camera_test cycle`); `camera_test noise` — уровень чёрного и шум каждого датчика в темноте (временной, фиксированный, строк) при усилении 1×…максимум. `camera_test raw` — кадры через `src/camera_isp.c` (замер, автоэкспозиция, баланс белого, гамма, NV12). Устройство появляется сразу при старте ядра (раньше mediaserverd, который ищет камеры один раз, при старте); чтения ждут, пока датчик не включится. `cam_pattern=1` — цветные полосы: собственные полосы датчика, если в файле модуля есть их таблица, иначе — генератора CSID (у широкой камеры таблица пустая, поэтому — CSID, как при `cam=3`, датчик тогда не включается вовсе); `cam_pattern=2` — всегда CSID. Для iOS: `libredwood-media.dylib` в mediaserverd даёт его `BWFigCaptureDeviceVendor` наше устройство захвата (`src/camera_device.c`: FigCaptureDevice и FigCaptureStream, производные объекты CoreMedia, как у H10ISP.mediacapture; форматы названы, как «Photo» и «Video-60» задней камеры в `D22/AVCaptureSession.plist`); AVFoundation перечисляет «Back Camera» с 16 форматами (`camera_avtest`), Camera.app открывается. НЕ ГОТОВО: до приложений кадры пока не доходят — сессия Camera.app берёт поток и тут же отдаёт его (граф захвата не строится), раз за разом; предпросмотр чёрный (`RC_JOBS=rc.jobs.camera`) |
+| `cam=N` | камеры: все четыре — макро, широкая, фронтальная и сверхширокая (`cam_sensor=macro|wide|front|ultra`, по умолчанию — макро, при `cam=5` — широкая); макрокамера — OmniVision OV02B10 (2 Мп, камера 2 Android, «redwood_aac_ov02b10_macro»); всё — из живого дерева устройств (cam-sensor2), файла модуля камеры Android (`/vendor/lib64/camera/com.qti.sensormodule.redwood_aac_ov02b10_macro.bin`: адрес, где и как читается ID чипа, порядок включения) и драйверов ядра Android (`bsd/dev/redwood_camera.c`). Датчик — на CCI 1, ведущий 0 (GPIO 73/74, здесь I2C вручную, как у других драйверов), адрес 0x3c; сброс — GPIO 77; MCLK — mclk2 camcc на 19,2 МГц на GPIO 66 (у Android эти 19,2 МГц — от PLL2 camcc, здесь — от самого кварца, без PLL); питание — LDO6 (1,8 В, DOVDD) и LDO7 (2,8 В, AVDD) PM8008i, который на I2C последовательного движка 1 (GPIO 4/5, адреса 0x08 и 0x09) и выходит из сброса по GPIO 3 PM8350C, как его выводит Android. `cam=1` — только смотреть: тактовые частоты и домен питания камеры, ножки, сброс PM8008i и, если он не в сбросе, сам PM8008i. `cam=2` — ещё и включить датчик в порядке файла модуля (у макрокамеры: сброс низкий, 1 мс; DOVDD; AVDD, 2 мс; верхний домен питания камеры и MCLK, 4 мс; сброс высокий, 9 мс), прочитать ID чипа так, как читает Android (16-битный регистр по 16-битному адресу 0x0203; ждёт 0x002b), и выключить в обратном порядке. Пределы: напряжения — только Android (1,8 и 2,8 В у макрокамеры, 1,0 и 1,8 В у широкой), записи — только в перечисленные регистры (у каждого устройства — список, проверяется при каждой записи), каждая читается обратно; неотвеченный байт, регулятор не готов вовремя или сообщает о перегрузке по току, запись не читается обратно — всё выключается и больше ничего не пишется; в конце сеанса и при панике включённое выключается, найденное включённым остаётся включённым. `cam_after=S` — через сколько секунд после старта (по умолчанию 20). `cam=3` — путь кадра без датчика: генератор тестовой картинки CSID-lite 0 (RAW10 1600×1200, цветные полосы) → его путь RDI 0 → IFE-lite 0, чей мастер записи 0 пишет кадр в память через SMMU (поток 0x800, маска 0x4e0, в свободный контекст с нашими таблицами); для этого — голоса RPMh за CX на SVS и MX на SVS_L1 (через вторую TCS DRV 2, в конце отдаются), PLL0 camcc (1,2 ГГц), RCG и ветви камеры на частотах уровня «svs» из дерева устройств (cphy_rx, CSID, IFE-lite — 400 МГц, таймер PHY — 300, camnoc — 150, slow_ahb — 80), всё — по драйверам Android (`camcc-yupik.c`, `cam_ife_csid_lite17x.h`, `cam_vfe_lite16x.h`, `cam_vfe_bus_ver2.c`). `cam=4` — кадры самого датчика: питание и ID, как при `cam=2`, его таблицы Android — инициализация (108 записей), режим (1600×1200 RAW10, одна линия, 665,6 Мбит/с, 30 кадров/с), «пуск», таблица экспозиции; CSIPHY 2 (v1.2.1, D-PHY, линия данных 0 и линия такта; число отсчётов установления — из файла модуля для этого режима, 20, `cam_settle=N` — своё), приёмник CSID-lite 0 от PHY 2 и тот же путь RDI 0 → IFE-lite 0 → SMMU → память; несколько кадров подряд в два места, последний остаётся; потом «стоп» и всё выключается. Таблицы читаются при запуске из `fw/camera-ov02b10.tab` малого образа: его делает `tools/camsensor.py` из файла модуля датчика Android (`fw-camera/com.qti.sensormodule.redwood_aac_ov02b10_macro.bin` с телефона; ни он, ни таблицы в git не попадают). `cam_pattern=1` — тестовые полосы самого датчика вместо изображения, `cam_frames=N` — сколько кадров (по умолчанию 8), `cam_shutter=СТРОК`, `cam_gain=N` — своя экспозиция и усиление. Память с кадрами загрузчик отдаёт после сеанса: `./xl camera [префикс]` забирает её и через `tools/camraw.py` делает картинки (`префикс-N.png` — по пикселю на ячейку 2×2 Байера, серый мир, гамма 2,2; `префикс-N-raw.png` — сырые значения; порядок Байера изображения датчика — RGGB: в снимке комнаты друг за другом следуют второй и третий отсчёты ячейки, то есть зелёные; его собственные полосы приходят со сдвигом на строку, как GBRG; `--bayer N` — другой порядок; `cam_vblank=СТРОК` — удлинить кадр для выдержки длиннее 1200 строк). `cam_sensor=wide` — то же для основной широкоугольной камеры, Samsung S5KHM2SD (108 Мп, камера 0 Android, «redwood_sunny_s5khm2sd_wide», cam-sensor0): CCI 0, ведущий 1 (GPIO 71/72), адрес 0x20, ID чипа 0xfad2 по адресу 0x0000; сброс — GPIO 21; MCLK — mclk1 camcc (19,2 МГц, GPIO 65); питание — LDO1 (1,0 В, VDIG) и LDO5 (1,8 В, VIO) PM8008i и VANA 2,8 В от постоянного регулятора, который включает GPIO 106 (всё — напряжения дерева устройств); порядок включения и выключения, ID, таблицы и режимы — из её файла модуля (`fw-camera/com.qti.sensormodule.redwood_sunny_s5khm2sd_wide.bin` → `fw/camera-s5khm2sd.tab`, формат RWCTAB02 — все режимы, порядок питания, назначение линий; инициализация — 1441 запись; шесть режимов, от 12000×9000 до 1920×1080 на 240 кадрах/с). Кадры — по трём трио C-PHY в CSIPHY 1 (трёхфазные таблицы v1.2.1 Android и строка таблицы скоростей, покрывающая скорость трио; число отсчётов установления — из файла модуля, 34), CSID-lite 0 — в режиме C-PHY. `cam_mode=N` — режим из таблицы датчика (по умолчанию — с наименьшим числом пикселей: у широкой — 1920×1080 RAW10 на 120 кадрах/с, 3,11 Гбит/с на трио). Порядок Байера широкой — GBRG (в снимке комнаты друг за другом следуют первый и четвёртый отсчёты; красный против синего — по сырым уровням обеих камер при одном тёплом свете), заголовок кадра говорит его сам. Экспозиция широкой — регистры SMIA внутри group hold 0x0104: `cam_vblank` — длина кадра 0x0340, `cam_shutter` — выдержка 0x0202, `cam_gain` — аналоговое усиление 0x0204 (32 — 1×). `cam_sensor=front` — фронтальная камера, OmniVision OV16A1Q (16 Мп, cam-sensor1, «redwood_aac_ov16a1q_front»): CCI 0, ведущий 0 (GPIO 69/70), адрес 0x10, ID чипа 0x1641 по адресу 0x300b; сброс — GPIO 20; MCLK — mclk0 (19,2 МГц, GPIO 64); питание — LDO3 (2,8 В, VANA), LDO2 (1,2 В, VDIG), LDO5 (1,8 В, VIO) PM8008i; четыре линии D-PHY в CSIPHY 0 (по умолчанию — режим 1920×1080 на 120 кадрах/с, 1,44 Гбит/с на линию). `cam_sensor=ultra` — сверхширокая, Samsung S5K4H7 (8 Мп, cam-sensor3, «redwood_sunny_s5k4h7_ultra»): CCI 1, ведущий 1 (GPIO 75/76), адрес 0x2d, ID чипа 0x487b по адресу 0; сброс — GPIO 78; MCLK — mclk3 на 24 МГц, как просит её файл модуля: от PLL2 camcc (Zonda, 1440 МГц, настройки `cam_cc_pll2_config` Android, запуск — как `clk_zonda_pll_enable()`), делитель 10 и M/N 1/6 (`ftbl_cam_cc_mclk0_clk_src`); питание — LDO4 (2,8 В, VANA), LDO5 (1,8 В, VIO) и VDIG 1,2 В от постоянного регулятора (`camera_ultra_dvdd_ldo`, от PM7325 S8), который включает GPIO 108; четыре линии D-PHY в CSIPHY 3. Собственных цветных полос (таблицы «tpgon» в файле модуля) нет ни у широкой, ни у фронтальной, ни у сверхширокой — только у макрокамеры; `cam_pattern=1` для остальных даёт их изображение (при `cam=4`) или полосы CSID (при `cam=5`). Выдержка по `cam_shutter`/`cam_gain`/`cam_vblank` при `cam=4` — только у макро и широкой; фронтальная и сверхширокая при `cam=4` снимают с выдержкой своих таблиц. Порядок Байера: макро и фронтальная — RGGB, широкая и сверхширокая — GBRG (зелёные — два равных по уровню отсчёта ячейки; красный против синего — по отношениям R/G и B/G, одинаковым у всех четырёх при одном свете). Память под два кадра `cam=3`/`cam=4` (до 12 МБ каждый) берётся одним куском при загрузке (`cam_keep_mb`). `cam=5` — широкая камера для iOS: устройство `/dev/redwood-camera` (`bsd/sys/redwood_camera.h`); первое чтение после открытия включает датчик и запускает кадры (режим — `cam_mode`, по умолчанию 1: 4000×3000 RAW10, 30 кадров/с), последнее закрытие, секунда без чтения или любая неисправность всё выключают (после неисправности — до конца сеанса). Кадры идут по кругу в три места памяти ядра (отображённые через SMMU постранично): одно пишет IFE, одно может копировать чтение, одно готово; в каждом начале кадра адрес места для следующего кадра уходит мастеру записи, который берёт его в следующем начале кадра (на это есть целый кадр, а не промежуток между кадрами); кадр, для которого адреса не оказалось, считается переписанным. Строка RAW10 у мастера записи выровнена на 16 байт (4000 пикселей — 5008 байт, а не 5000). `read()` отдаёт заголовок (номер, время, выдержка, усиление, длина кадра и строки) и сам кадр; `write()` принимает другой датчик (`REDWOOD_CAMERA_SENSOR`: кадры останавливаются, всё выключается, следующее чтение включает другой; номер датчика — в заголовке кадра; режим по умолчанию — самый крупный 4:3 не быстрее 30 кадров/с и не больше 13 Мп: широкая 4000×3000, фронтальная 2304×1728, сверхширокая 3264×2448, макро 1600×1200; выдержка из `write()` пишется каждому его способом в его group hold: SMIA у широкой и сверхширокой — 0x0340/0x0202/0x0204, у фронтальной OV16A1Q — 0x380e/0x380f, 0x3500…0x3502, 0x3508/0x3509 (0x100 — 1×), у макро OV02B10 — страница 1: 0x14/0x15, 0x0e/0x0f, 0x22 (16 — 1×); предел усиления — свой у каждого: 64× у широкой, 16× у сверхширокой, 15,5× у фронтальной и макро), выдержку и усиление (пишутся между кадрами в group hold, с пределами: усиление от 1× до предела датчика, кадр не длиннее 0xfff0 строк) или картинку для хоста (память под неё — `cam_keep_mb`, по умолчанию 24, берётся при загрузке одним куском; `./xl camera` её забирает, `tools/camraw.py` понимает NV12 и BGRA). Проверка всех четырёх по очереди — `RC_JOBS=rc.jobs.cameras` (`camera_test cycle`); `camera_test noise` — уровень чёрного и шум каждого датчика в темноте (временной, фиксированный, строк) при усилении 1×…максимум. `camera_test raw` — кадры через `src/camera_isp.c` (замер, автоэкспозиция, баланс белого, цветовая матрица, гамма, NV12 BT.601 с округлением до ближайшего: полосы CSID `cam_pattern=2` с `noae noawb` выходят основными цветами с точностью до шага — точнее 8-битный YCbCr красный и синий не передаёт); `full` — каждый пиксель (билинейная демозаика в размер датчика, 8 потоков; на резких цветовых границах — кайма в 1–2 пикселя от демозаики и общей цветности 2×2), `ccm M` — своя цветовая матрица (девять чисел через запятую; по умолчанию единичная: настоящей нужна цветовая мишень). Устройство появляется сразу при старте ядра (раньше mediaserverd, который ищет камеры один раз, при старте); чтения ждут, пока датчик не включится. `cam_pattern=1` — цветные полосы: собственные полосы датчика, если в файле модуля есть их таблица, иначе — генератора CSID (у широкой камеры таблица пустая, поэтому — CSID, как при `cam=3`, датчик тогда не включается вовсе); `cam_pattern=2` — всегда CSID. Для iOS: `libredwood-media.dylib` в mediaserverd даёт его `BWFigCaptureDeviceVendor` наше устройство захвата (`src/camera_device.c`: FigCaptureDevice и FigCaptureStream, производные объекты CoreMedia, как у H10ISP.mediacapture; форматы названы, как «Photo» и «Video-60» задней камеры в `D22/AVCaptureSession.plist`); AVFoundation перечисляет «Back Camera» с 16 форматами (`camera_avtest`), Camera.app открывается. НЕ ГОТОВО: до приложений кадры пока не доходят — сессия Camera.app берёт поток и тут же отдаёт его (граф захвата не строится), раз за разом; предпросмотр чёрный (`RC_JOBS=rc.jobs.camera`) |
| `mic=N` | с `adsp=1`, основной микрофон (`bsd/dev/redwood_mic.c`, значения Android). `mic=1` — только посмотреть: звуковой процессор голосует за блоки LPASS и даёт тактовые частоты макроса TX (19,2 МГц), регистры макросов TX и VA, ведущего SoundWire, ножек LPASS и сброса кодека читаются; без всех четырёх ни один регистр не трогается. `mic=2` — ещё и кодек поднят настолько, чтобы ответить по SoundWire: сброс (GPIO83) отпущен, как это делает Android, ножки ведущего (LPASS GPIO 0, 1, 2, 14) — в активное состояние Android, тактовые частоты макроса TX, ведущий запущен, устройство TX кодека перечислено и его номер прочитан. `mic=3` — ещё и запись с микрофона `mic_secs` секунд (по умолчанию 10, не больше 600): настройка кодека, как в `wcd938x_init_reg()`, смещение микрофона 2750 мВ, ADC1 в режиме «low power», «ADC1 Volume» 6, дециматор 1 и порт codec DMA, шина SoundWire как на пути Android «handset-mic» (выше). Каждая запись читается обратно, любое расхождение или отказ звукового процессора — всё останавливается. Для проверки: `mic_input=0` (дециматор слушает ноль — точная тишина), `mic_adc=0`, `mic_test=1` (без смещения), `mic_test=2` (вход ADC1 удержан), `mic_main=1`, `mic_tap=1` с `haptic=5`. `mic=4` — микрофон для iOS: путь до кодека поднимается, только пока iOS записывает (пока открыт `/dev/redwood-mic`, кольцо на 341 мс, чтение никогда не ждёт и держится в 40 мс за звуковым процессором), а в плагине звука `RedwoodAudio.driver` есть устройство «Codec» с одним входом и источником данных `imic` («Bottom»), из которого VirtualAudio, как на iPhone, делает «iPhone Microphone» (Built-In Microphone). Приложения записывают с него: «Диктофон» пишет и рисует волну (`RC_JOBS=rc.jobs.voicememos`), `record_test` (AVAudioRecorder) — 6,00 с из 6,00, на частоте мотора 175,5 Гц с `haptic=5` уровень растёт с −68 до −29 дБFS (`RC_JOBS=rc.jobs.mic`, с `sound=4 sound_below=720` — сначала беззвучная проверка динамиков). Программа без интерфейса, записывающая в фоне, получает оранжевую точку, но не плашку записи в строке состояния, и MediaSafetyNet в mediaserverd, как на iPhone, через девять секунд такой записи останавливает mediaserverd; записи `record_test` поэтому короче и с паузой между ними. В конце и при выключении звукового процессора всё возвращается как было: кодек снова в сбросе, ножки и регистры как были |
| `battmgr=0` | с `adsp=1` батарея не спрашивается. Без него (по умолчанию) ядро раз в 10 с спрашивает у звукового процессора, который у этого телефона и ведёт батарею с зарядкой (как Android — `qti_battery_charger`, Linux — `qcom_battmgr` поверх `pmic_glink`), по каналу `PMIC_RTR_ADSP_APPS` процент заряда, зарядку, напряжение, ток, температуру, заряд в мА·ч, ёмкость, циклы и что даёт порт USB — только читает, ни пределов, ни токов не задаёт — и показывает это iOS так же, как батарея iPhone: службой `RedwoodBattery` класса `IOPMPowerSource` (`iokit/Kernel/RedwoodBattery.cpp`). Её читает powerd, и дальше всё делает сама iOS: батарея с процентом и молнией в строке состояния, «58% Charged» на экране блокировки, виджет «Батареи», Настройки → Аккумулятор (переключатель «Заряд в процентах» работает; в образе он включён); перехваты батареи в SpringBoard при этой службе уступают iOS. Сверено с Android (`dumpsys battery` и `/sys/class/power_supply/battery` сразу после): 56 % и 58 %, «заряжается», напряжение, температура, заряд, ёмкость 3677 из 5000 мА·ч, 890 циклов совпадают. Номера свойств — этой прошивки: до 9-го как у Linux, дальше на один больше; `battmgr=2` пишет в журнал все. Те же числа — в `kern.redwood.battery_*`. С `battery=1` (путь загрузчика через UEFI) не включается. Историю заряда и расход по приложениям iOS 16 берёт из журнала энергии, который ведёт aggregated (`com.apple.powerlog.plxpclogger.xpc` и другие службы; база `CurrentPowerlog.PLSQL`); раньше он был в списке не запускаемых (`userland/mkjobs.py`), и страница «Аккумулятор» вечно крутила колёсико. Теперь она открывается сразу: в первые минуты — «As you use your iPhone, battery usage will be reported here» (так iOS говорит, пока данных о расходе нет), через час — график уровня заряда за 24 часа и список приложений («Connected to Charger», пока телефон на зарядке); экран всё это время iOS считала выключенным («Screen On 0m»), отчего — ещё не разобрано. Расход в процентах по приложениям iOS считает из энергии частей системы на кристалле, которую на iPhone сообщают счётчики IOReport («Energy Model»); их здесь нет. Не показывается износ в «Состоянии аккумулятора» (powerd ждёт серийный номер батареи, а его прошивка не даёт; вместо цифры колёсико). Проверка — `RC_JOBS=rc.jobs.battery` (`battery_test`), `RC_JOBS=rc.jobs.battery2` (страницы Настроек, в конце `battery_test powerlog`: что журнал энергии собрал — таблицы, строки, время), `RC_JOBS=rc.jobs.battery3` (то же после часа работы приложений) |
diff --git a/userland/src/camera_isp.c b/userland/src/camera_isp.c
index 96a100b..6bfd14f 100644
--- a/userland/src/camera_isp.c
+++ b/userland/src/camera_isp.c
@@ -1,9 +1,12 @@
/*
- * The wide camera's frames made into pictures by the processor (see camera_isp.h). A first version:
- * one pixel per 2x2 cell (no interpolation), the nearest cell for each pixel of the picture, grey
- * world white balance, no colour matrix, no lens shading, no noise reduction.
+ * The cameras' frames made into pictures by the processor (see camera_isp.h): one pixel per 2x2
+ * cell, the nearest cell for each pixel of the picture (previews), or every pixel by bilinear
+ * demosaic (stills); per pixel, in this order: the black level off, lens shading (a grid of gains per
+ * colour, when there is one), the white balance's and AE's gains, the colour matrix (identity until
+ * one is set), sRGB's curve. Grey-world white balance; no noise reduction yet.
*/
#include <math.h>
+#include <stdlib.h>
#include <string.h>
#include "camera_isp.h"
@@ -16,6 +19,9 @@ isp_init(struct isp *isp)
memset(isp, 0, sizeof(*isp));
isp->wb[0] = isp->wb[1] = isp->wb[2] = 1;
isp->digital = 1;
+ for (int i = 0; i < 3; i++) {
+ isp->ccm[i][i] = 1;
+ }
for (int i = 0; i < 4096; i++) {
double v = i >= LUT_WHITE ? 1 : (double)i / LUT_WHITE;
@@ -180,36 +186,145 @@ crop(const struct redwood_camera_frame *f, uint32_t width, uint32_t height, uint
*y0 = (h - *ch) / 2;
}
+void
+isp_set_ccm(struct isp *isp, const float m[9])
+{
+ for (int i = 0; i < 9; i++) {
+ isp->ccm[i / 3][i % 3] = m[i];
+ }
+}
+
+/*
+ * The colour matrix with the white balance's and AE's gains folded in, in the gamma table's steps
+ * (per 10-bit step above black): out[c] = sum over j of m[c][j] * value[j] (each value lens-shaded).
+ */
+struct pipe {
+ float m[3][3];
+ bool identity;
+};
+
+static void
+pipe_init(const struct isp *isp, struct pipe *p)
+{
+ p->identity = true;
+ for (int c = 0; c < 3; c++) {
+ for (int j = 0; j < 3; j++) {
+ p->m[c][j] = isp->ccm[c][j] * isp->wb[j] * isp->digital * (LUT_WHITE / (float)WHITE);
+ p->identity = p->identity && (c == j ? isp->ccm[c][j] == 1 : isp->ccm[c][j] == 0);
+ }
+ }
+}
+
+static inline uint8_t
+curve(const struct isp *isp, float v)
+{
+ int i = (int)(v + 0.5f);
+
+ return isp->gamma[i < 0 ? 0 : i > 4095 ? 4095 : i];
+}
+
+static inline void
+pixel(const struct isp *isp, const struct pipe *p, float r, float g, float b, uint8_t *rgb)
+{
+ if (p->identity) {
+ rgb[0] = curve(isp, r * p->m[0][0]);
+ rgb[1] = curve(isp, g * p->m[1][1]);
+ rgb[2] = curve(isp, b * p->m[2][2]);
+ return;
+ }
+ rgb[0] = curve(isp, p->m[0][0] * r + p->m[0][1] * g + p->m[0][2] * b);
+ rgb[1] = curve(isp, p->m[1][0] * r + p->m[1][1] * g + p->m[1][2] * b);
+ rgb[2] = curve(isp, p->m[2][0] * r + p->m[2][1] * g + p->m[2][2] * b);
+}
+
+/* the lens shading's gains at (u, v), 0 to 1 across the sensor */
+static inline void
+lsc_at(const struct isp *isp, float u, float v, float g[3])
+{
+ float gx = u * (LSC_W - 1), gy = v * (LSC_H - 1);
+ int x = (int)gx, y = (int)gy;
+
+ x = x < 0 ? 0 : x > LSC_W - 2 ? LSC_W - 2 : x;
+ y = y < 0 ? 0 : y > LSC_H - 2 ? LSC_H - 2 : y;
+ float fx = gx - x, fy = gy - y;
+
+ for (int c = 0; c < 3; c++) {
+ const float (*t)[LSC_W] = isp->lsc.gain[c];
+
+ g[c] = (t[y][x] * (1 - fx) + t[y][x + 1] * fx) * (1 - fy) + (t[y + 1][x] * (1 - fx) + t[y + 1][x + 1] * fx) * fy;
+ }
+}
+
/* one line of the picture as 8-bit R, G, B */
static void
render_line(const struct isp *isp, const struct redwood_camera_frame *f, const uint8_t *raw, uint32_t width, uint32_t height,
uint32_t row, uint8_t *rgb)
{
- uint32_t x0, y0, cw, ch, k[3];
+ uint32_t x0, y0, cw, ch, cells_w = f->width / 2, cells_h = f->height / 2;
int r, b;
+ struct pipe p;
crop(f, width, height, &x0, &y0, &cw, &ch);
cell_places(f->bayer, &r, &b);
- for (int c = 0; c < 3; c++) {
- k[c] = (uint32_t)(isp->wb[c] * isp->digital * 4 * 256);
- }
- const uint8_t *top = raw + (size_t)(y0 + (uint64_t)row * ch / height) * 2 * f->stride;
+ pipe_init(isp, &p);
+ uint32_t cy = y0 + (uint32_t)((uint64_t)row * ch / height);
+ const uint8_t *top = raw + (size_t)cy * 2 * f->stride;
uint64_t step = ((uint64_t)cw << 16) / width, at = (uint64_t)x0 << 16;
+ float v_pos = cells_h > 1 ? (float)cy / (cells_h - 1) : 0, gains[3] = { 1, 1, 1 };
for (uint32_t x = 0; x < width; x++, at += step) {
+ uint32_t cx = (uint32_t)(at >> 16);
int v[4], g = 0;
- uint32_t i;
- cell(top, f->stride, (uint32_t)(at >> 16), v);
+ cell(top, f->stride, cx, v);
for (int j = 0; j < 4; j++) {
g += j != r && j != b ? v[j] : 0;
}
- i = (uint32_t)v[r] * k[0] >> 8;
- rgb[3 * x] = isp->gamma[i > 4095 ? 4095 : i];
- i = (uint32_t)g * k[1] >> 9;
- rgb[3 * x + 1] = isp->gamma[i > 4095 ? 4095 : i];
- i = (uint32_t)v[b] * k[2] >> 8;
- rgb[3 * x + 2] = isp->gamma[i > 4095 ? 4095 : i];
+ if (isp->lsc.on) {
+ lsc_at(isp, cells_w > 1 ? (float)cx / (cells_w - 1) : 0, v_pos, gains);
+ }
+ pixel(isp, &p, v[r] * gains[0], g * 0.5f * gains[1], v[b] * gains[2], rgb + 3 * x);
+ }
+}
+
+/*
+ * Two lines of 8-bit R, G, B as NV12 (BT.601's matrix, which CoreVideo's 420f and 420v and
+ * tools/camraw.py take): each pixel's Y (y1 NULL: the second line has none, the picture's last of an
+ * odd height), each 2x2's Cb and Cr from the sum of its four. The coefficients in 1/65536ths, video
+ * range's scaled to its 219 steps of luma (16 to 235) and 224 of chroma (16 to 240); every value
+ * rounded to the nearest step, so that the primaries come back within one step of 0 and 255 (red's and
+ * blue's cannot be exact: no 8-bit Y, Cb, Cr is both).
+ */
+static void
+nv12_pair(const uint8_t *rgb0, const uint8_t *rgb1, uint32_t width, uint8_t *y0, uint8_t *y1, uint8_t *uv, bool video_range)
+{
+ static const int32_t full[9] = { 19595, 38470, 7471, -11058, -21710, 32768, 32768, -27439, -5329 };
+ static const int32_t video[9] = { 16829, 33039, 6416, -9714, -19070, 28784, 28784, -24103, -4681 };
+ const int32_t *k = video_range ? video : full;
+ int32_t oy = (video_range ? 16 << 16 : 0) + (1 << 15);
+
+ for (int l = 0; l < 2; l++) {
+ const uint8_t *p = l ? rgb1 : rgb0;
+ uint8_t *out = l ? y1 : y0;
+
+ for (uint32_t x = 0; out != NULL && x < width; x++, p += 3) {
+ out[x] = (uint8_t)((k[0] * p[0] + k[1] * p[1] + k[2] * p[2] + oy) >> 16);
+ }
+ }
+ for (uint32_t x = 0; x < width; x += 2) {
+ uint32_t x1 = x + 1 < width ? x + 1 : x;
+ int32_t R = rgb0[3 * x] + rgb0[3 * x1] + rgb1[3 * x] + rgb1[3 * x1];
+ int32_t G = rgb0[3 * x + 1] + rgb0[3 * x1 + 1] + rgb1[3 * x + 1] + rgb1[3 * x1 + 1];
+ int32_t B = rgb0[3 * x + 2] + rgb0[3 * x1 + 2] + rgb1[3 * x + 2] + rgb1[3 * x1 + 2];
+ /*
+ * (the sums are four pixels': 18 bits off, with 128 added and just under half a step to round;
+ * a tie goes down, so that chroma's -127.5, a full colour's, comes out 0 as its +127.5 does 255)
+ */
+ int32_t cb = (k[3] * R + k[4] * G + k[5] * B + (128 << 18) + (1 << 17) - 1) >> 18;
+ int32_t cr = (k[6] * R + k[7] * G + k[8] * B + (128 << 18) + (1 << 17) - 1) >> 18;
+
+ uv[x] = (uint8_t)(cb < 0 ? 0 : cb > 255 ? 255 : cb);
+ uv[x + 1] = (uint8_t)(cr < 0 ? 0 : cr > 255 ? 255 : cr);
}
}
@@ -217,36 +332,18 @@ void
isp_render_nv12(const struct isp *isp, const struct redwood_camera_frame *f, const uint8_t *raw, uint8_t *y, size_t y_stride,
uint8_t *uv, size_t uv_stride, uint32_t width, uint32_t height, uint32_t first_row, uint32_t end_row, bool video_range)
{
- /* video range: luma 16 to 235, chroma 16 to 240 (219 and 224 steps of the full 255) */
- int ly = video_range ? 219 : 256, lc = video_range ? 224 : 256, oy = video_range ? 16 : 0;
uint8_t line[2][3 * 8192];
if (width > 8192) {
return;
}
- for (uint32_t row = first_row & ~1u; row < end_row && row + 1 < height + 1; row += 2) {
- render_line(isp, f, raw, width, height, row, line[0]);
- render_line(isp, f, raw, width, height, row + 1 < height ? row + 1 : row, line[1]);
- for (int l = 0; l < 2 && row + l < height; l++) {
- uint8_t *out = y + (size_t)(row + l) * y_stride;
- const uint8_t *p = line[l];
-
- for (uint32_t x = 0; x < width; x++, p += 3) {
- out[x] = (uint8_t)(oy + (((77 * p[0] + 150 * p[1] + 29 * p[2]) >> 8) * ly >> 8));
- }
- }
- uint8_t *o = uv + (size_t)(row / 2) * uv_stride;
-
- for (uint32_t x = 0; x + 1 < width + 1; x += 2) {
- uint32_t x1 = x + 1 < width ? x + 1 : x;
- int R = line[0][3 * x] + line[0][3 * x1] + line[1][3 * x] + line[1][3 * x1];
- int G = line[0][3 * x + 1] + line[0][3 * x1 + 1] + line[1][3 * x + 1] + line[1][3 * x1 + 1];
- int B = line[0][3 * x + 2] + line[0][3 * x1 + 2] + line[1][3 * x + 2] + line[1][3 * x1 + 2];
- int cb = (((-43 * R - 85 * G + 128 * B) >> 10) * lc >> 8) + 128, cr = (((128 * R - 107 * G - 21 * B) >> 10) * lc >> 8) + 128;
+ for (uint32_t row = first_row & ~1u; row < end_row && row < height; row += 2) {
+ bool second = row + 1 < height;
- o[x] = (uint8_t)(cb < 0 ? 0 : cb > 255 ? 255 : cb);
- o[x + 1] = (uint8_t)(cr < 0 ? 0 : cr > 255 ? 255 : cr);
- }
+ render_line(isp, f, raw, width, height, row, line[0]);
+ render_line(isp, f, raw, width, height, second ? row + 1 : row, line[1]);
+ nv12_pair(line[0], line[1], width, y + (size_t)row * y_stride, second ? y + (size_t)(row + 1) * y_stride : NULL,
+ uv + (size_t)(row / 2) * uv_stride, video_range);
}
}
@@ -271,3 +368,180 @@ isp_render_bgra(const struct isp *isp, const struct redwood_camera_frame *f, con
}
}
}
+
+/* ---- every pixel: bilinear demosaic -------------------------------------------------------------------- */
+
+/* the colour of each site of a 2x2 cell (0 R, 1 G, 2 B), position y * 2 + x */
+static void
+cfa(uint32_t bayer, int colour[4])
+{
+ int r, b;
+
+ cell_places(bayer, &r, &b);
+ for (int i = 0; i < 4; i++) {
+ colour[i] = i == r ? 0 : i == b ? 2 : 1;
+ }
+}
+
+/* line y of the frame as values above black (y clamped into the frame) */
+static void
+unpack_line(const struct redwood_camera_frame *f, const uint8_t *raw, int y, int *out)
+{
+ y = y < 0 ? 0 : y >= (int)f->height ? (int)f->height - 1 : y;
+ const uint8_t *line = raw + (size_t)y * f->stride;
+
+ for (uint32_t x = 0; x + 3 < f->width + 3 && x < f->width; x += 4) {
+ const uint8_t *g = line + (x >> 2) * 5;
+
+ for (int i = 0; i < 4 && x + i < f->width; i++) {
+ int v = (g[i] << 2 | (g[4] >> (i * 2) & 3)) - (int)f->black;
+
+ out[x + i] = v < 0 ? 0 : v;
+ }
+ }
+}
+
+/* one line (y) at full size as 8-bit R, G, B, from the lines y - 1, y, y + 1 (l[0..2]) */
+static void
+full_line(const struct isp *isp, const struct redwood_camera_frame *f, const int *const l[3], uint32_t y, const int colour[4],
+ const struct pipe *p, uint8_t *rgb)
+{
+ int w = (int)f->width;
+ float v_pos = f->height > 1 ? (float)y / (f->height - 1) : 0, gains[3] = { 1, 1, 1 };
+
+ for (int x = 0; x < w; x++) {
+ float sum[3] = { 0, 0, 0 };
+ int n[3] = { 0, 0, 0 };
+
+ /* each colour: its own value where the site has it, else the mean of its sites in the 3x3 around */
+ for (int dy = -1; dy <= 1; dy++) {
+ const int *line = l[dy + 1];
+ int yy = (int)y + dy;
+
+ yy = yy < 0 ? 0 : yy >= (int)f->height ? (int)f->height - 1 : yy;
+ for (int dx = -1; dx <= 1; dx++) {
+ int xx = x + dx < 0 ? 0 : x + dx >= w ? w - 1 : x + dx;
+ int c = colour[(yy & 1) * 2 + (xx & 1)];
+
+ if (dx == 0 && dy == 0) {
+ sum[c] = (float)line[xx] * 64; /* (its own value wins over the neighbours') */
+ n[c] = 64;
+ } else if (n[c] < 64) {
+ sum[c] += (float)line[xx];
+ n[c]++;
+ }
+ }
+ }
+ if (isp->lsc.on) {
+ lsc_at(isp, w > 1 ? (float)x / (w - 1) : 0, v_pos, gains);
+ }
+ pixel(isp, p, sum[0] / (n[0] ? n[0] : 1) * gains[0], sum[1] / (n[1] ? n[1] : 1) * gains[1],
+ sum[2] / (n[2] ? n[2] : 1) * gains[2], rgb + 3 * x);
+ }
+}
+
+void
+isp_render_full_nv12(const struct isp *isp, const struct redwood_camera_frame *f, const uint8_t *raw, uint8_t *y, size_t y_stride,
+ uint8_t *uv, size_t uv_stride, uint32_t first_row, uint32_t end_row, bool video_range)
+{
+ uint32_t width = f->width;
+ int colour[4];
+ struct pipe p;
+ static __thread int *lines[4];
+ static __thread uint8_t *rgb[2];
+ static __thread uint32_t have;
+
+ if (width > have) {
+ for (int i = 0; i < 4; i++) {
+ free(lines[i]);
+ lines[i] = malloc(sizeof(int) * width);
+ }
+ for (int i = 0; i < 2; i++) {
+ free(rgb[i]);
+ rgb[i] = malloc(3 * (size_t)width);
+ }
+ have = width;
+ }
+ cfa(f->bayer, colour);
+ pipe_init(isp, &p);
+ for (uint32_t row = first_row & ~1u; row < end_row && row < f->height; row += 2) {
+ for (int i = 0; i < 4; i++) {
+ unpack_line(f, raw, (int)row - 1 + i, lines[i]);
+ }
+ const int *const above[3] = { lines[0], lines[1], lines[2] }, *const below[3] = { lines[1], lines[2], lines[3] };
+
+ bool second = row + 1 < f->height;
+
+ full_line(isp, f, above, row, colour, &p, rgb[0]);
+ full_line(isp, f, below, second ? row + 1 : row, colour, &p, rgb[1]);
+ nv12_pair(rgb[0], rgb[1], width, y + (size_t)row * y_stride, second ? y + (size_t)(row + 1) * y_stride : NULL,
+ uv + (size_t)(row / 2) * uv_stride, video_range);
+ }
+}
+
+/* ---- lens shading from a flat field --------------------------------------------------------------------- */
+
+bool
+isp_lsc_from_flat(struct isp *isp, const struct redwood_camera_frame *f, const uint8_t *raw, float *min_ratio)
+{
+ uint32_t cells_w = f->width / 2, cells_h = f->height / 2, half_w = cells_w / (LSC_W - 1) / 2, half_h = cells_h / (LSC_H - 1) / 2;
+ float level[3][LSC_H][LSC_W], top[3] = { 0, 0, 0 };
+ uint32_t clipped = 0, seen = 0;
+ int r, b;
+
+ cell_places(f->bayer, &r, &b);
+ for (int gy = 0; gy < LSC_H; gy++) {
+ for (int gx = 0; gx < LSC_W; gx++) {
+ int cx0 = (int)((uint64_t)gx * (cells_w - 1) / (LSC_W - 1)) - (int)half_w;
+ int cy0 = (int)((uint64_t)gy * (cells_h - 1) / (LSC_H - 1)) - (int)half_h;
+ double sum[3] = { 0, 0, 0 };
+ uint32_t n = 0;
+
+ for (int cy = cy0; cy <= cy0 + 2 * (int)half_h; cy += 2) {
+ for (int cx = cx0; cx <= cx0 + 2 * (int)half_w; cx += 2) {
+ int v[4];
+
+ if (cx < 0 || cy < 0 || cx >= (int)cells_w || cy >= (int)cells_h) {
+ continue;
+ }
+ cell(raw + (size_t)cy * 2 * f->stride, f->stride, (uint32_t)cx, v);
+ sum[0] += v[r];
+ sum[2] += v[b];
+ for (int j = 0; j < 4; j++) {
+ sum[1] += j != r && j != b ? v[j] / 2.0 : 0;
+ clipped += v[j] > WHITE - 30;
+ }
+ seen += 4;
+ n++;
+ }
+ }
+ for (int c = 0; c < 3; c++) {
+ level[c][gy][gx] = n ? (float)(sum[c] / n) : 0;
+ top[c] = level[c][gy][gx] > top[c] ? level[c][gy][gx] : top[c];
+ }
+ }
+ }
+ /* bright enough to tell shading from noise, and not clipped anywhere that counts */
+ if (top[1] < 100 || clipped * 1000 > seen) {
+ return false;
+ }
+ float darkest = 1;
+
+ for (int c = 0; c < 3; c++) {
+ for (int gy = 0; gy < LSC_H; gy++) {
+ for (int gx = 0; gx < LSC_W; gx++) {
+ float l = level[c][gy][gx] > 1 ? level[c][gy][gx] : 1;
+
+ isp->lsc.gain[c][gy][gx] = top[c] / l;
+ if (c == 1 && l / top[c] < darkest) {
+ darkest = l / top[c];
+ }
+ }
+ }
+ }
+ isp->lsc.on = true;
+ if (min_ratio != NULL) {
+ *min_ratio = darkest;
+ }
+ return true;
+}
diff --git a/userland/src/camera_isp.h b/userland/src/camera_isp.h
index efefe3f..5c3f084 100644
--- a/userland/src/camera_isp.h
+++ b/userland/src/camera_isp.h
@@ -1,8 +1,10 @@
/*
- * What the phone's ISP would do with the wide camera's RAW10 frames, done by the processor instead
+ * What the phone's ISP would do with the cameras' RAW10 frames, done by the processor instead
* (src/camera_isp.c): the levels of a frame, the exposure for the next ones (AE), the white balance
- * (AWB), and a picture: each 2x2 Bayer cell one pixel of colour, scaled to the size asked for, the
- * gains, a gamma, as 8-bit YCbCr 4:2:0 (NV12, full range: CoreVideo's 420f) or BGRA.
+ * (AWB), and a picture: each 2x2 Bayer cell one pixel of colour, scaled to the size asked for, or
+ * every pixel (bilinear demosaic) at the sensor's own size; lens shading (a grid of gains per
+ * colour), the white balance's and AE's gains, a colour matrix, a gamma; as 8-bit YCbCr 4:2:0 (NV12,
+ * full range: CoreVideo's 420f, or video range: 420v) or BGRA.
*/
#ifndef CAMERA_ISP_H
#define CAMERA_ISP_H
@@ -19,9 +21,22 @@ struct isp_stats {
uint32_t cells;
};
+/*
+ * Lens shading: a gain for each colour at each point of a grid laid over the sensor (corners on its
+ * corners), between the points bilinear. Off until it is given one (isp_lsc_from_flat()).
+ */
+#define LSC_W 17
+#define LSC_H 13
+struct isp_lsc {
+ bool on;
+ float gain[3][LSC_H][LSC_W];
+};
+
struct isp {
float wb[3]; /* the white balance's gains, green 1 */
float digital; /* more gain, for what AE cannot reach with the sensor's */
+ float ccm[3][3]; /* the colour matrix, camera RGB (white balanced) to linear sRGB; rows sum to 1 */
+ struct isp_lsc lsc;
uint8_t gamma[4096]; /* linear (959 above black is 3836) to 8 bits, sRGB's curve */
uint32_t asked_lines, asked_gain, asked_frame_lines; /* what AE asked for last */
bool asked;
@@ -44,5 +59,18 @@ void isp_render_nv12(const struct isp *isp, const struct redwood_camera_frame *f
uint8_t *uv, size_t uv_stride, uint32_t width, uint32_t height, uint32_t first_row, uint32_t end_row, bool video_range);
void isp_render_bgra(const struct isp *isp, const struct redwood_camera_frame *f, const uint8_t *raw, uint8_t *out, size_t stride,
uint32_t width, uint32_t height, uint32_t first_row, uint32_t end_row);
+/*
+ * Every pixel at the sensor's own size (f->width x f->height): the two colours a site does not have
+ * from the same colour's sites around it (bilinear); rows from first_row to end_row (even), NV12.
+ */
+void isp_render_full_nv12(const struct isp *isp, const struct redwood_camera_frame *f, const uint8_t *raw, uint8_t *y, size_t y_stride,
+ uint8_t *uv, size_t uv_stride, uint32_t first_row, uint32_t end_row, bool video_range);
+/*
+ * Lens shading measured from a frame of a flat field (a white sheet held over the lens, evenly lit):
+ * each colour's level at each grid point (a block's mean) over the brightest of its own; false if
+ * the frame is too dark or clipped for it. min_ratio: the darkest point's level over the brightest's.
+ */
+bool isp_lsc_from_flat(struct isp *isp, const struct redwood_camera_frame *f, const uint8_t *raw, float *min_ratio);
+void isp_set_ccm(struct isp *isp, const float m[9]);
#endif
diff --git a/userland/src/camera_test.c b/userland/src/camera_test.c
index 1a91a81..fffed67 100644
--- a/userland/src/camera_test.c
+++ b/userland/src/camera_test.c
@@ -1,15 +1,17 @@
/*
* camera_test: the wide camera's frames as a program gets them (cam=5).
*
- * usage: camera_test raw [FRAMES] [noae] [noawb] [keepraw] [sensor N]
+ * usage: camera_test raw [FRAMES] [noae] [noawb] [keepraw|full] [ccm M] [sensor N]
* camera_test cycle [FRAMES]
* camera_test noise [SENSOR|all]
* raw: reads FRAMES frames (default 150) from the kernel's /dev/redwood-camera, with src/camera_isp.c's
* exposure (unless noae: the kernel's, boot-args cam_shutter and cam_gain) and white balance working
* on them, says what came and how fast, and leaves the last one as a picture for the host (xl
- * camera: logs/, never the repository): one pixel a cell, NV12, or with keepraw the frame itself.
+ * camera: logs/, never the repository): one pixel a cell, NV12, or with full every pixel (bilinear
+ * demosaic, at the sensor's size), or with keepraw the frame itself.
* With sensor N, another sensor first (0 the macro, 1 the wide, 2 the front, 3 the ultra-wide); with
- * noawb, no white balance (gains of 1: for colour bars, whose colours are known).
+ * noawb, no white balance (gains of 1: for colour bars, whose colours are known); with ccm M, the
+ * colour matrix M (nine numbers, row by row, separated by commas: a check of the matrix's path).
* cycle: each of the four sensors in turn, FRAMES frames each (default 30), the kernel's exposure:
* what came of each, and how long the change from one to the next took.
* noise: the sensor's black level and noise in the dark (the lens covered, or a dark room): at the
@@ -18,6 +20,7 @@
* over the square root of 2), the fixed pattern (what is left of the two frames' mean), the rows'
* noise (how much whole lines move together); for one sensor (0 to 3) or all four.
*/
+#include <dispatch/dispatch.h>
#include <errno.h>
#include <fcntl.h>
#include <math.h>
@@ -266,8 +269,28 @@ noise(const char *which)
return failures ? 1 : 0;
}
+/* a piece of a picture of every pixel (one of 8 bands of lines, each an even number of them) */
+struct full_job {
+ const struct isp *isp;
+ const struct redwood_camera_frame *f;
+ const uint8_t *raw;
+ uint8_t *y, *uv;
+ uint32_t width;
+};
+
+static void
+full_piece(void *context, size_t i)
+{
+ struct full_job *j = context;
+ uint32_t rows = (j->f->height / 8 + 1) & ~1u, first = (uint32_t)i * rows, end = i == 7 ? j->f->height : first + rows;
+
+ isp_render_full_nv12(j->isp, j->f, j->raw, j->y, j->width, j->uv, j->width, first, end, false);
+}
+
+static float ccm[9] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
+
static int
-raw(int frames, bool ae, bool awb, bool keep_raw, int sensor)
+raw(int frames, bool ae, bool awb, bool keep_raw, bool full, int sensor)
{
struct redwood_camera_frame head, *f;
struct isp isp;
@@ -297,6 +320,7 @@ raw(int frames, bool ae, bool awb, bool keep_raw, int sensor)
bytes = sizeof(head) + (size_t)head.stride * head.height;
f = malloc(bytes);
isp_init(&isp);
+ isp_set_ccm(&isp, ccm);
while (got < frames && failures < 5) {
struct redwood_camera_command c;
uint64_t t0 = mach_absolute_time();
@@ -354,15 +378,21 @@ raw(int frames, bool ae, bool awb, bool keep_raw, int sensor)
close(device);
return 0;
}
- /* the last one, as a picture for the host: one pixel per cell, NV12 */
- uint32_t w = f->width / 2, h = f->height / 2;
+ /* the last one, as a picture for the host: one pixel per cell, or every pixel; NV12 */
+ uint32_t w = full ? f->width : f->width / 2, h = full ? f->height : f->height / 2;
size_t picture = (size_t)w * h * 3 / 2;
struct redwood_camera_command *keep = malloc(sizeof(*keep) + picture);
uint8_t *y = (uint8_t *)(keep + 1);
uint64_t t0 = mach_absolute_time();
- isp_render_nv12(&isp, f, (const uint8_t *)f + f->header_bytes, y, w, y + (size_t)w * h, w, w, h, 0, h, false);
- printf("camera_test: the picture (%ux%u NV12) made in %.1f ms\n", w, h, ms_since(t0));
+ if (full) {
+ struct full_job job = { &isp, f, (const uint8_t *)f + f->header_bytes, y, y + (size_t)w * h, w };
+
+ dispatch_apply_f(8, dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), &job, full_piece);
+ } else {
+ isp_render_nv12(&isp, f, (const uint8_t *)f + f->header_bytes, y, w, y + (size_t)w * h, w, w, h, 0, h, false);
+ }
+ printf("camera_test: the picture (%ux%u NV12%s) made in %.1f ms\n", w, h, full ? ", every pixel" : "", ms_since(t0));
memset(keep, 0, sizeof(*keep));
keep->command = REDWOOD_CAMERA_KEEP;
keep->bytes = (uint32_t)picture;
@@ -384,18 +414,30 @@ main(int argc, char **argv)
{
setvbuf(stdout, NULL, _IOLBF, 0);
if (argc >= 2 && strcmp(argv[1], "raw") == 0) {
- bool ae = true, awb = true, keep_raw = false;
+ bool ae = true, awb = true, keep_raw = false, full = false;
int sensor = -1;
for (int i = 3; i < argc; i++) {
ae = ae && strcmp(argv[i], "noae") != 0;
awb = awb && strcmp(argv[i], "noawb") != 0;
keep_raw = keep_raw || strcmp(argv[i], "keepraw") == 0;
+ full = full || strcmp(argv[i], "full") == 0;
+ if (strcmp(argv[i], "ccm") == 0 && i + 1 < argc) {
+ const char *at = argv[++i];
+
+ for (int k = 0; k < 9 && at != NULL; k++) {
+ ccm[k] = strtof(at, NULL);
+ at = strchr(at, ',');
+ at = at != NULL ? at + 1 : NULL;
+ }
+ printf("camera_test: the colour matrix %.2f %.2f %.2f / %.2f %.2f %.2f / %.2f %.2f %.2f\n", ccm[0], ccm[1],
+ ccm[2], ccm[3], ccm[4], ccm[5], ccm[6], ccm[7], ccm[8]);
+ }
if (strcmp(argv[i], "sensor") == 0 && i + 1 < argc) {
sensor = atoi(argv[++i]);
}
}
- return raw(argc >= 3 ? atoi(argv[2]) : 150, ae, awb, keep_raw, sensor);
+ return raw(argc >= 3 ? atoi(argv[2]) : 150, ae, awb, keep_raw, full, sensor);
}
if (argc >= 2 && strcmp(argv[1], "noise") == 0) {
return noise(argc >= 3 ? argv[2] : "all");
@@ -403,6 +445,6 @@ main(int argc, char **argv)
if (argc >= 2 && strcmp(argv[1], "cycle") == 0) {
return cycle(argc >= 3 ? atoi(argv[2]) : 30);
}
- fprintf(stderr, "usage: camera_test raw [FRAMES] [noae] [noawb] [keepraw] [sensor N]\n camera_test cycle [FRAMES]\n camera_test noise [SENSOR|all]\n");
+ fprintf(stderr, "usage: camera_test raw [FRAMES] [noae] [noawb] [keepraw|full] [ccm M] [sensor N]\n camera_test cycle [FRAMES]\n camera_test noise [SENSOR|all]\n");
return 2;
}