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.mdindex 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.cindex 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 voidrender_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 @@ voidisp_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.hindex 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 *fuint8_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]);#endifdiff --git a/userland/src/camera_test.c b/userland/src/camera_test.cindex 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;}