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

Microphone for iOS: applications record from the phone's main microphone (mic=4)

vcvkk2bb073e91714
diff --git a/README.md b/README.md
index 031e81a..bb6a0c6 100644
--- a/README.md
+++ b/README.md
@@ -286,7 +286,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; потом кнопка в Пункте управления) |
-| `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=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` (то же после часа работы приложений) |
Несколько ядер на телефоне проверены (2, 4 и 7 ядер запускаются и чисто возвращаются в загрузчик). На одном и
diff --git a/userland/build.sh b/userland/build.sh
index 835437b..0cd3e60 100755
--- a/userland/build.sh
+++ b/userland/build.sh
@@ -113,6 +113,10 @@ if [ -d $IOS/rootfs/usr/lib ]; then
$DYN -framework CoreFoundation -framework AudioToolbox -framework AVFoundation -lobjc -o obj/sound_test src/sound_test.c
$DYN -framework CoreFoundation -lMobileGestalt -o obj/mg_test src/mg_test.c
$DYN -framework CoreFoundation -framework AVFoundation -lobjc -o obj/torch_test src/torch_test.c
+ # (the microphone as an application records: allowed to, by an entitlement, if ldid is there)
+ $DYN -framework CoreFoundation -framework AVFoundation -lobjc -o obj/record_test src/record_test.c &&
+ { ${LDID:-ldid} -Ssrc/record_test.entitlements obj/record_test 2>/dev/null ||
+ echo "build.sh: no ldid: record_test is unsigned, and the system may not let it record"; }
$DYN -o obj/cpu_test src/cpu_test.c
$DYN -framework CoreFoundation -framework IOSurface -o obj/cow_test src/cow_test.c
$DYN -framework CoreFoundation -framework CoreGraphics -framework IOSurface -o obj/cg_test src/cg_test.c
@@ -168,6 +172,7 @@ if [ -d $IOS/rootfs/usr/lib ]; then
[ -f obj/wifipw_test ] && cp obj/wifipw_test root/bin/
[ -f obj/sound_test ] && cp obj/sound_test root/bin/
[ -f obj/torch_test ] && cp obj/torch_test root/bin/
+ [ -f obj/record_test ] && cp obj/record_test root/bin/
for f in $EXTRA; do cp "$f" root/bin/; done
mkdir -p root/lib
cp obj/libredwood.dylib obj/libredwood-sb.dylib root/lib/
diff --git a/userland/rc.jobs.mic b/userland/rc.jobs.mic
new file mode 100644
index 0000000..cd1023f
--- /dev/null
+++ b/userland/rc.jobs.mic
@@ -0,0 +1,15 @@
+# Commands run by the launchd job com.redwood.demo (see com.redwood.demo.plist).
+# The microphone for iOS (RC_JOBS=rc.jobs.mic, with adsp=1 mic=4, haptic=5 and sound=4): first the speakers' path
+# as a check (a tone of two seconds and a keyboard click; with sound_below=720 the amplifiers play it 90 dB under
+# Android's level, which is silence), then two recordings the way an application makes them (record_test:
+# AVAudioRecorder through the built-in microphone, which the virtual audio device makes of RedwoodAudio.driver's
+# "Codec", whose samples come from the kernel's /dev/redwood-mic): six seconds with the vibration motor running
+# from the third to the fourth (its 175.5 Hz is what the microphone should hear), then four seconds of the room. The
+# kernel's "mic:" lines say when the microphone listened, and the end of the run repeats them. (A pause between
+# the two: a program in the background that records shows the orange dot but not the status bar's recording pill, and
+# mediaserverd's MediaSafetyNet stops itself after nine seconds of a microphone in use without the pill, as on
+# an iPhone; the pause lets it see the microphone off.)
+/redwood/bin/sound_test springboard route wait 2 tone 2 wait 4 system 1104 wait 4
+/redwood/bin/record_test 6 vibrate 3
+/redwood/bin/rwtouch wait 3
+/redwood/bin/record_test 4
diff --git a/userland/rc.jobs.voicememos b/userland/rc.jobs.voicememos
new file mode 100644
index 0000000..401ce5b
--- /dev/null
+++ b/userland/rc.jobs.voicememos
@@ -0,0 +1,8 @@
+# Commands run by the launchd job com.redwood.demo (see com.redwood.demo.plist).
+# The microphone in an application (with adsp=1 mic=4): Voice Memos opened (voicememos://), past its welcome sheet
+# (Continue), and its record button pressed; it records until the run ends. For screenshots: the time running, the
+# waveform of what the microphone hears, the orange dot of a microphone in use.
+/redwood/bin/sound_test springboard
+/redwood/bin/rwtouch wait 10
+/redwood/bin/battery_test open voicememos://
+/redwood/bin/rwtouch wait 10 tap 0.5 0.895 wait 10 tap 0.5 0.885 wait 30
diff --git a/userland/src/audio_plugin.c b/userland/src/audio_plugin.c
index c5e2679..4bef2dd 100644
--- a/userland/src/audio_plugin.c
+++ b/userland/src/audio_plugin.c
@@ -14,7 +14,7 @@
* through which everything in iOS is routed. It knows an iPhone's own devices by their names
* (their UIDs) and makes a port of each: "Speaker" becomes the speaker port, the route an iPhone
* with nothing plugged in plays through, with a volume, the volume display and the place in
- * Control Center that go with it. So this presents three devices under those names:
+ * Control Center that go with it. So this presents four devices under those names:
*
* "Speaker" a stereo output whose samples are written to /dev/redwood-audio, where the
* kernel takes them to whatever can play them (see sys/redwood_audio.h), and a
@@ -26,6 +26,10 @@
* "Actuator" one output of one channel: the iPhone's Taptic Engine, on which iOS plays its
* haptics as waveforms (through the chain 'd22_actuator_general'); its samples go to
* the kernel's motor driver, /dev/redwood-haptic (see actuator_write())
+ * "Codec" one input of one channel: on an iPhone, the audio codec that the built-in
+ * microphones are on, of which the virtual audio device makes the built-in microphone
+ * port; its samples come from the kernel, /dev/redwood-mic (the phone's main
+ * microphone, boot-arg mic=4), which listens only while this input runs (see codec_read())
*
* CoreAudio's own null device ("Null_Device", described in the framework's Info.plist, playing
* into nowhere) stays as it is: it is the only device the virtual audio device takes while it
@@ -159,6 +163,9 @@ enum {
kAudioDevicePropertySafetyOffset = 'saft', kAudioDevicePropertyNominalSampleRate = 'nsrt',
kAudioDevicePropertyAvailableNominalSampleRates = 'nsr#', kAudioDevicePropertyIsHidden = 'hidn',
kAudioDevicePropertyPreferredChannelsForStereo = 'dch2', kAudioDevicePropertyZeroTimeStampPeriod = 'ring',
+ kAudioSelectorControlClassID = 'slct', kAudioDataSourceControlClassID = 'dsrc',
+ kAudioSelectorControlPropertyCurrentItem = 'scci', kAudioSelectorControlPropertyAvailableItems = 'scai',
+ kAudioSelectorControlPropertyItemName = 'scin', kAudioSelectorControlPropertyItemKind = 'clkk',
kAudioStreamPropertyIsActive = 'sact', kAudioStreamPropertyDirection = 'sdir', kAudioStreamPropertyTerminalType = 'term',
kAudioStreamPropertyStartingChannel = 'schn', kAudioStreamPropertyLatency = 'ltnc',
@@ -187,8 +194,10 @@ enum {
OBJECT_SPEAKER, OBJECT_SPEAKER_OUTPUT, OBJECT_SPEAKER_INPUT,
OBJECT_HAWKING, OBJECT_HAWKING_INPUT,
OBJECT_ACTUATOR, OBJECT_ACTUATOR_OUTPUT,
+ OBJECT_CODEC, OBJECT_CODEC_INPUT,
OBJECT_SPEAKER_VOLUME, /* the speaker output's volume control */
- OBJECT_LAST = OBJECT_SPEAKER_VOLUME
+ OBJECT_CODEC_SOURCE, /* the codec input's data source control: its microphones */
+ OBJECT_LAST = OBJECT_CODEC_SOURCE
};
#define VOLUME_RANGE_DB 48.0 /* from the loudest the kernel allows down to the quietest step above 0 */
@@ -209,10 +218,19 @@ static struct device devices[] = {
.output_channels = REDWOOD_AUDIO_CHANNELS, .input_channels = 2 },
{ .object = OBJECT_HAWKING, .uid = CFSTR("Hawking"), .input = OBJECT_HAWKING_INPUT, .input_channels = 1 },
{ .object = OBJECT_ACTUATOR, .uid = CFSTR("Actuator"), .output = OBJECT_ACTUATOR_OUTPUT, .output_channels = 1 },
+ { .object = OBJECT_CODEC, .uid = CFSTR("Codec"), .input = OBJECT_CODEC_INPUT, .input_channels = 1 },
};
#define DEVICES (sizeof(devices) / sizeof(devices[0]))
#define TRANSPORT_BUILT_IN 'bltn'
+/*
+ * The codec's input has data sources, one for each microphone, and the virtual audio device will not
+ * take a codec without them (VirtualAudio asks for kAudioDevicePropertyDataSources on its input, and
+ * keeps those it knows: 'imic', 'smic', 'fmic', 'lmic', 'tmic', 'umic', 'imi1' to 'imi4'). A plug-in
+ * has them as a data source control on the input, which the HAL answers those properties from. There
+ * is one microphone here, at the bottom: 'imic', the iPhone's internal (bottom) one.
+ */
+#define MIC_SOURCE 'imic'
#define MANUFACTURER CFSTR("redwood")
/* how often a device says where its clock is, in frames: also the largest I/O buffer the HAL will use */
#define TIMESTAMP_PERIOD 16384
@@ -430,6 +448,40 @@ property(AudioObjectID object, const AudioObjectPropertyAddress *address, UInt32
}
return v;
}
+ if (object == OBJECT_CODEC_SOURCE) {
+ switch (selector) {
+ case kAudioObjectPropertyBaseClass:
+ WORD(kAudioSelectorControlClassID);
+ break;
+ case kAudioObjectPropertyClass:
+ WORD(kAudioDataSourceControlClassID);
+ break;
+ case kAudioObjectPropertyOwner:
+ WORD(OBJECT_CODEC);
+ break;
+ case kAudioObjectPropertyOwnedObjects:
+ v.empty = true;
+ break;
+ case kAudioControlPropertyScope:
+ WORD(kAudioObjectPropertyScopeInput);
+ break;
+ case kAudioControlPropertyElement:
+ WORD(0);
+ break;
+ case kAudioSelectorControlPropertyCurrentItem:
+ case kAudioSelectorControlPropertyAvailableItems:
+ WORD(MIC_SOURCE);
+ break;
+ case kAudioSelectorControlPropertyItemName:
+ if (qualifier_size == sizeof(UInt32) && qualifier != NULL && *(const UInt32 *)qualifier == MIC_SOURCE) {
+ STRING(CFSTR("Bottom"));
+ } else {
+ STRING(CFSTR(""));
+ }
+ break;
+ }
+ return v;
+ }
if (object != OBJECT_PLUGIN && d == NULL) {
return v;
}
@@ -518,12 +570,18 @@ property(AudioObjectID object, const AudioObjectPropertyAddress *address, UInt32
if (selector == kAudioObjectPropertyOwnedObjects && d->object == OBJECT_SPEAKER) {
LIST(OBJECT_SPEAKER_VOLUME);
}
+ if (selector == kAudioObjectPropertyOwnedObjects && d->object == OBJECT_CODEC && scope != kAudioObjectPropertyScopeOutput) {
+ LIST(OBJECT_CODEC_SOURCE);
+ }
v.empty = v.size == 0;
break;
case kAudioObjectPropertyControlList:
if (d->object == OBJECT_SPEAKER) {
LIST(OBJECT_SPEAKER_VOLUME);
}
+ if (d->object == OBJECT_CODEC) {
+ LIST(OBJECT_CODEC_SOURCE);
+ }
v.empty = v.size == 0;
break;
case kAudioDevicePropertyNominalSampleRate:
@@ -580,6 +638,37 @@ property(AudioObjectID object, const AudioObjectPropertyAddress *address, UInt32
return v;
}
+/*
+ * What the HAL (or the virtual audio device through it) asks of an object that it does not have,
+ * the first times for each object, selector and scope: what a device it will not take may lack.
+ */
+#define UNKNOWN_TOLD 64
+static UInt32 unknown_told[UNKNOWN_TOLD][3];
+static unsigned unknown_count;
+
+static void
+unknown(AudioObjectID object, const AudioObjectPropertyAddress *address)
+{
+ UInt32 s = address->mSelector, c = address->mScope;
+
+ for (unsigned i = 0; i < unknown_count; i++) {
+ if (unknown_told[i][0] == object && unknown_told[i][1] == s && unknown_told[i][2] == c) {
+ return;
+ }
+ }
+ if (unknown_count >= UNKNOWN_TOLD) {
+ return;
+ }
+ unknown_told[unknown_count][0] = object;
+ unknown_told[unknown_count][1] = s;
+ unknown_told[unknown_count][2] = c;
+ unknown_count++;
+ say("redwood: audio: asked of object %u (%s) what it does not have: '%c%c%c%c' (%#x), scope '%c%c%c%c', element %u\n",
+ (unsigned)object, device_of(object) ? CFStringGetCStringPtr(device_of(object)->uid, kCFStringEncodingUTF8) : "-",
+ (int)(s >> 24 & 0xff), (int)(s >> 16 & 0xff), (int)(s >> 8 & 0xff), (int)(s & 0xff), (unsigned)s,
+ (int)(c >> 24 & 0xff), (int)(c >> 16 & 0xff), (int)(c >> 8 & 0xff), (int)(c & 0xff), (unsigned)address->mElement);
+}
+
static Boolean
has_property(__unused AudioServerPlugInDriverRef driver, AudioObjectID object, __unused pid_t client,
const AudioObjectPropertyAddress *address)
@@ -590,6 +679,9 @@ has_property(__unused AudioServerPlugInDriverRef driver, AudioObjectID object, _
return false;
}
v = property(object, address, 0, NULL);
+ if (v.size == 0 && !v.empty) {
+ unknown(object, address);
+ }
return v.size != 0 || v.empty;
}
@@ -606,6 +698,8 @@ is_property_settable(AudioServerPlugInDriverRef driver, AudioObjectID object, pi
if (object == OBJECT_SPEAKER_VOLUME) {
*settable = address->mSelector == kAudioLevelControlPropertyScalarValue ||
address->mSelector == kAudioLevelControlPropertyDecibelValue;
+ } else if (object == OBJECT_CODEC_SOURCE) {
+ *settable = address->mSelector == kAudioSelectorControlPropertyCurrentItem;
} else if (object == OBJECT_PLUGIN) {
*settable = false;
} else if (object == d->object) {
@@ -703,6 +797,11 @@ set_property_data(AudioServerPlugInDriverRef driver, AudioObjectID object, pid_t
}
return 0;
}
+ if (object == OBJECT_CODEC_SOURCE) {
+ /* the one microphone there is */
+ return size == sizeof(UInt32) ? (*(const UInt32 *)data == MIC_SOURCE ? 0 : kAudioHardwareIllegalOperationError) :
+ kAudioHardwareBadPropertySizeError;
+ }
if (address->mSelector == kAudioStreamPropertyIsActive) {
if (size != sizeof(UInt32)) {
return kAudioHardwareBadPropertySizeError;
@@ -727,6 +826,59 @@ set_property_data(AudioServerPlugInDriverRef driver, AudioObjectID object, pid_t
}
}
+/*
+ * The microphone (the device "Codec"): /dev/redwood-mic is open while the input runs, and the kernel
+ * listens only while it is open. A read gives what has come and never waits; what it does not
+ * give is silence. Said when it starts and stops, with how much came.
+ */
+static int mic = -1;
+static UInt64 mic_frames, mic_heard, mic_short;
+static int mic_peak;
+
+static void
+codec_open(void)
+{
+ mic = open("/dev/redwood-mic", O_RDONLY | O_NONBLOCK);
+ mic_frames = mic_heard = mic_short = 0;
+ mic_peak = 0;
+ say("redwood: audio: the microphone is listened to (/dev/redwood-mic: %s)\n", mic < 0 ? strerror(errno) : "open");
+}
+
+static void
+codec_close(void)
+{
+ say("redwood: audio: the microphone stops: %llu.%02llu s asked for, %llu.%02llu s of it from the kernel (peak %d of 32768), "
+ "%llu reads short\n", mic_frames / REDWOOD_AUDIO_RATE, mic_frames % REDWOOD_AUDIO_RATE * 100 / REDWOOD_AUDIO_RATE,
+ mic_heard / REDWOOD_AUDIO_RATE, mic_heard % REDWOOD_AUDIO_RATE * 100 / REDWOOD_AUDIO_RATE, mic_peak, mic_short);
+ if (mic >= 0) {
+ close(mic);
+ }
+ mic = -1;
+}
+
+static void
+codec_read(int16_t *samples, UInt32 frames)
+{
+ ssize_t got = mic >= 0 ? read(mic, samples, (size_t)frames * 2) : -1;
+ UInt32 have = got > 0 ? (UInt32)got / 2 : 0;
+
+ if (have > 0 && mic_heard == 0) {
+ say("redwood: audio: the microphone's first samples, %llu.%02llu s after the input started\n",
+ mic_frames / REDWOOD_AUDIO_RATE, mic_frames % REDWOOD_AUDIO_RATE * 100 / REDWOOD_AUDIO_RATE);
+ }
+ for (UInt32 i = 0; i < have; i++) {
+ int v = samples[i] < 0 ? -samples[i] : samples[i];
+
+ mic_peak = v > mic_peak ? v : mic_peak;
+ }
+ if (have < frames) {
+ memset(samples + have, 0, (size_t)(frames - have) * 2);
+ mic_short += mic_heard > 0;
+ }
+ mic_frames += frames;
+ mic_heard += have;
+}
+
static OSStatus
start_io(__unused AudioServerPlugInDriverRef driver, AudioObjectID object, __unused UInt32 client)
{
@@ -743,6 +895,9 @@ start_io(__unused AudioServerPlugInDriverRef driver, AudioObjectID object, __unu
written = refused = 0;
say("redwood: audio: playing\n");
}
+ if (d->object == OBJECT_CODEC) {
+ codec_open();
+ }
}
pthread_mutex_unlock(&lock);
return 0;
@@ -757,9 +912,13 @@ stop_io(__unused AudioServerPlugInDriverRef driver, AudioObjectID object, __unus
return kAudioHardwareBadObjectError;
}
pthread_mutex_lock(&lock);
- if (d->running != 0 && --d->running == 0 && d->output != 0) {
- say("redwood: audio: stopped after %llu.%02llu s (%llu frames not taken by %s)\n", written / REDWOOD_AUDIO_RATE,
- written % REDWOOD_AUDIO_RATE * 100 / REDWOOD_AUDIO_RATE, refused, REDWOOD_AUDIO_DEVICE);
+ if (d->running != 0 && --d->running == 0) {
+ if (d->object == OBJECT_CODEC) {
+ codec_close();
+ } else if (d->output != 0) {
+ say("redwood: audio: stopped after %llu.%02llu s (%llu frames not taken by %s)\n", written / REDWOOD_AUDIO_RATE,
+ written % REDWOOD_AUDIO_RATE * 100 / REDWOOD_AUDIO_RATE, refused, REDWOOD_AUDIO_DEVICE);
+ }
}
pthread_mutex_unlock(&lock);
return 0;
@@ -849,8 +1008,10 @@ do_io_operation(__unused AudioServerPlugInDriverRef driver, __unused AudioObject
if (d == NULL) {
return kAudioHardwareBadObjectError;
}
- if (operation == kAudioServerPlugInIOOperationReadInput) {
- /* nobody is listening on this machine: silence */
+ if (operation == kAudioServerPlugInIOOperationReadInput && stream == OBJECT_CODEC_INPUT) {
+ codec_read(buffer, frames);
+ } else if (operation == kAudioServerPlugInIOOperationReadInput) {
+ /* the speaker's and Hawking's inputs: silence */
memset(buffer, 0, (size_t)frames * 2 * d->input_channels);
} else if (operation == kAudioServerPlugInIOOperationWriteMix && stream == OBJECT_ACTUATOR_OUTPUT) {
actuator_write(buffer, frames);
diff --git a/userland/src/record_test.c b/userland/src/record_test.c
new file mode 100644
index 0000000..fa0750d
--- /dev/null
+++ b/userland/src/record_test.c
@@ -0,0 +1,325 @@
+/*
+ * record_test: record from the microphone the way an application does, and say what came.
+ *
+ * usage: record_test SECONDS [vibrate AT]
+ *
+ * An audio session for recording (AVAudioSession: play and record, haptics allowed while recording),
+ * then AVAudioRecorder into a WAV file of 16-bit samples at 48 kHz, one channel, in /tmp (in memory
+ * on this machine), its meters read every tenth of a second. With "vibrate AT", AT seconds into the
+ * recording the phone's motor runs for one second (CoreHaptics, a continuous event at full strength):
+ * something the microphone hears that nobody needs to say, at a frequency one can look for, the
+ * motor's resonance (175.5 Hz on the POCO X5 Pro). Then the file is read back: how loud each tenth
+ * of a second is, and how strong 175.5 Hz is before the vibration and while it lasts.
+ *
+ * On this machine the samples come from the kernel's /dev/redwood-mic (boot-arg mic=4), through
+ * RedwoodAudio.driver's device "Codec" (audio_plugin.c), of which the virtual audio device makes
+ * the built-in microphone.
+ */
+#include <CoreFoundation/CoreFoundation.h>
+#include <dlfcn.h>
+#include <math.h>
+#include <objc/message.h>
+#include <objc/runtime.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define PATH "/tmp/record_test.wav"
+#define RATE 48000
+#define MOTOR_HZ 175.5
+
+static id
+send(id object, const char *selector)
+{
+ return object ? ((id (*)(id, SEL))objc_msgSend)(object, sel_registerName(selector)) : NULL;
+}
+
+static const char *
+text(id object)
+{
+ id description = object ? send(object, "description") : NULL;
+ const char *utf8 = description ? ((const char *(*)(id, SEL))objc_msgSend)(description, sel_registerName("UTF8String")) : NULL;
+
+ return utf8 ? utf8 : "(none)";
+}
+
+static unsigned long
+count_of(id array)
+{
+ return array ? ((unsigned long (*)(id, SEL))objc_msgSend)(array, sel_registerName("count")) : 0;
+}
+
+static id
+item(id array, unsigned long i)
+{
+ return ((id (*)(id, SEL, unsigned long))objc_msgSend)(array, sel_registerName("objectAtIndex:"), i);
+}
+
+/* a constant (NSString *) of a framework, by name */
+static id
+constant(const char *framework_path, const char *name)
+{
+ void *framework = dlopen(framework_path, RTLD_NOW);
+ id *value = framework ? dlsym(framework, name) : NULL;
+
+ return value ? *value : NULL;
+}
+
+#define AVFAUDIO "/System/Library/Frameworks/AVFAudio.framework/AVFAudio"
+#define COREHAPTICS "/System/Library/Frameworks/CoreHaptics.framework/CoreHaptics"
+
+static void
+ports(const char *what, id list)
+{
+ unsigned long n = count_of(list);
+
+ printf("record_test: %s: %lu\n", what, n);
+ for (unsigned long i = 0; i < n; i++) {
+ id port = item(list, i);
+
+ printf("record_test: %s \"%s\" (%s)\n", text(send(port, "portType")), text(send(port, "portName")),
+ text(send(port, "UID")));
+ }
+}
+
+/* The audio session, set up for recording; false if it will not be. */
+static bool
+session_up(void)
+{
+ id session = send((id)objc_getClass("AVAudioSession"), "sharedInstance"), error = NULL;
+ id category = constant(AVFAUDIO, "AVAudioSessionCategoryPlayAndRecord");
+ BOOL ok;
+
+ if (session == NULL || category == NULL) {
+ printf("record_test: no AVAudioSession\n");
+ return false;
+ }
+ if (((BOOL (*)(id, SEL, SEL))objc_msgSend)(session, sel_registerName("respondsToSelector:"),
+ sel_registerName("recordPermission"))) {
+ unsigned long permission = ((unsigned long (*)(id, SEL))objc_msgSend)(session, sel_registerName("recordPermission"));
+
+ printf("record_test: the permission to record: %c%c%c%c\n", (int)(permission >> 24 & 0xff), (int)(permission >> 16 & 0xff),
+ (int)(permission >> 8 & 0xff), (int)(permission & 0xff));
+ }
+ ok = ((BOOL (*)(id, SEL, id, id *))objc_msgSend)(session, sel_registerName("setCategory:error:"), category, &error);
+ printf("record_test: the category play-and-record: %s%s\n", ok ? "set" : "NOT SET: ", ok ? "" : text(error));
+ if (!ok) {
+ return false;
+ }
+ ok = ((BOOL (*)(id, SEL, BOOL, id *))objc_msgSend)(session, sel_registerName("setAllowHapticsAndSystemSoundsDuringRecording:error:"),
+ YES, &error);
+ printf("record_test: haptics while recording: %s%s\n", ok ? "allowed" : "NOT ALLOWED: ", ok ? "" : text(error));
+ ok = ((BOOL (*)(id, SEL, BOOL, id *))objc_msgSend)(session, sel_registerName("setActive:error:"), YES, &error);
+ printf("record_test: the session: %s%s\n", ok ? "active" : "NOT ACTIVE: ", ok ? "" : text(error));
+ if (!ok) {
+ return false;
+ }
+ printf("record_test: input available: %s\n", ((BOOL (*)(id, SEL))objc_msgSend)(session,
+ sel_registerName("isInputAvailable")) ? "yes" : "NO");
+ ports("available inputs", send(session, "availableInputs"));
+ ports("the route's inputs", send(send(session, "currentRoute"), "inputs"));
+ ports("the route's outputs", send(send(session, "currentRoute"), "outputs"));
+ return true;
+}
+
+/* one second of the motor at full strength, started without waiting for it */
+static id
+vibrate(void)
+{
+ id error = NULL, engine, pattern, player, event;
+ const void *parameters[2], *events[1];
+ CFArrayRef list, none = CFArrayCreate(NULL, NULL, 0, &kCFTypeArrayCallBacks);
+
+ if (constant(COREHAPTICS, "CHHapticEventTypeHapticContinuous") == NULL) {
+ printf("record_test: no CoreHaptics\n");
+ return NULL;
+ }
+ engine = ((id (*)(id, SEL, id *))objc_msgSend)(send((id)objc_getClass("CHHapticEngine"), "alloc"),
+ sel_registerName("initAndReturnError:"), &error);
+ if (engine == NULL || !((BOOL (*)(id, SEL, id *))objc_msgSend)(engine, sel_registerName("startAndReturnError:"), &error)) {
+ printf("record_test: the haptic engine does not start: %s\n", text(error));
+ return NULL;
+ }
+ parameters[0] = ((id (*)(id, SEL, id, float))objc_msgSend)(send((id)objc_getClass("CHHapticEventParameter"), "alloc"),
+ sel_registerName("initWithParameterID:value:"), constant(COREHAPTICS, "CHHapticEventParameterIDHapticIntensity"), 1.0f);
+ parameters[1] = ((id (*)(id, SEL, id, float))objc_msgSend)(send((id)objc_getClass("CHHapticEventParameter"), "alloc"),
+ sel_registerName("initWithParameterID:value:"), constant(COREHAPTICS, "CHHapticEventParameterIDHapticSharpness"), 0.3f);
+ list = CFArrayCreate(NULL, parameters, 2, &kCFTypeArrayCallBacks);
+ event = ((id (*)(id, SEL, id, id, double, double))objc_msgSend)(send((id)objc_getClass("CHHapticEvent"), "alloc"),
+ sel_registerName("initWithEventType:parameters:relativeTime:duration:"),
+ constant(COREHAPTICS, "CHHapticEventTypeHapticContinuous"), (id)list, 0.0, 1.0);
+ events[0] = event;
+ list = CFArrayCreate(NULL, events, 1, &kCFTypeArrayCallBacks);
+ pattern = ((id (*)(id, SEL, id, id, id *))objc_msgSend)(send((id)objc_getClass("CHHapticPattern"), "alloc"),
+ sel_registerName("initWithEvents:parameters:error:"), (id)list, (id)none, &error);
+ player = pattern ? ((id (*)(id, SEL, id, id *))objc_msgSend)(engine, sel_registerName("createPlayerWithPattern:error:"),
+ pattern, &error) : NULL;
+ if (player == NULL ||
+ !((BOOL (*)(id, SEL, double, id *))objc_msgSend)(player, sel_registerName("startAtTime:error:"), 0.0, &error)) {
+ printf("record_test: the vibration does not play: %s\n", text(error));
+ return NULL;
+ }
+ printf("record_test: the motor runs for 1 s\n");
+ return engine;
+}
+
+static CFNumberRef
+number(int value)
+{
+ return CFNumberCreate(NULL, kCFNumberIntType, &value);
+}
+
+/* The power of one frequency in samples [from, to): Goertzel, as dB of full scale (a full-scale sine is 0). */
+static double
+tone_db(const int16_t *samples, long from, long to, double hz)
+{
+ double w = 2 * M_PI * hz / RATE, c = 2 * cos(w), s1 = 0, s2 = 0, power;
+ long n = to - from;
+
+ if (n <= 0) {
+ return -200;
+ }
+ for (long i = from; i < to; i++) {
+ double window = 0.5 - 0.5 * cos(2 * M_PI * (i - from) / (n - 1)), s0 = samples[i] / 32768.0 * window + c * s1 - s2;
+
+ s2 = s1;
+ s1 = s0;
+ }
+ power = s1 * s1 + s2 * s2 - c * s1 * s2;
+ /* (a Hann window halves the amplitude: a full-scale sine gives (n/4)^2) */
+ return 10 * log10(power / ((n / 4.0) * (n / 4.0)) + 1e-20);
+}
+
+static double
+rms_db(const int16_t *samples, long from, long to)
+{
+ double sum = 0;
+
+ for (long i = from; i < to; i++) {
+ sum += (double)samples[i] * samples[i];
+ }
+ return to > from ? 10 * log10(sum / (to - from) / (32768.0 * 32768.0) + 1e-20) : -200;
+}
+
+/* The file read back: the samples of its data chunk. */
+static int
+analyse(double seconds, double vibrate_at)
+{
+ FILE *file = fopen(PATH, "rb");
+ unsigned char header[12], chunk[8];
+ int16_t *samples = NULL;
+ long count = 0, peak = 0;
+
+ if (file == NULL || fread(header, 1, 12, file) != 12 || memcmp(header, "RIFF", 4) != 0 || memcmp(header + 8, "WAVE", 4) != 0) {
+ printf("record_test: %s is not a WAV file\n", PATH);
+ return 1;
+ }
+ while (fread(chunk, 1, 8, file) == 8) {
+ uint32_t size = chunk[4] | chunk[5] << 8 | chunk[6] << 16 | (uint32_t)chunk[7] << 24;
+
+ if (memcmp(chunk, "data", 4) == 0) {
+ samples = malloc(size + 2);
+ count = (long)fread(samples, 1, size, file) / 2;
+ break;
+ }
+ fseek(file, (long)(size + (size & 1)), SEEK_CUR);
+ }
+ fclose(file);
+ if (samples == NULL || count == 0) {
+ printf("record_test: %s has no samples\n", PATH);
+ return 1;
+ }
+ for (long i = 0; i < count; i++) {
+ long v = samples[i] < 0 ? -(long)samples[i] : samples[i];
+
+ peak = v > peak ? v : peak;
+ }
+ printf("record_test: the file: %ld samples (%.2f s of %.2f), peak %ld of 32768, %.1f dBFS RMS over all\n", count,
+ (double)count / RATE, seconds, peak, rms_db(samples, 0, count));
+ printf("record_test: dBFS RMS of each tenth of a second:");
+ for (long at = 0; at + RATE / 10 <= count; at += RATE / 10) {
+ printf(" %.0f", rms_db(samples, at, at + RATE / 10));
+ }
+ printf("\n");
+ if (vibrate_at > 0) {
+ long quiet_from = (long)(0.5 * RATE), quiet_to = (long)(vibrate_at * RATE) - RATE / 10;
+ long loud_from = (long)((vibrate_at + 0.15) * RATE), loud_to = (long)((vibrate_at + 0.95) * RATE);
+
+ loud_to = loud_to < count ? loud_to : count;
+ printf("record_test: before the vibration %.1f dBFS RMS, %.1f dBFS at %.1f Hz; while it lasts %.1f dBFS RMS, %.1f dBFS at %.1f "
+ "Hz\n", rms_db(samples, quiet_from, quiet_to), tone_db(samples, quiet_from, quiet_to, MOTOR_HZ), MOTOR_HZ,
+ rms_db(samples, loud_from, loud_to), tone_db(samples, loud_from, loud_to, MOTOR_HZ), MOTOR_HZ);
+ }
+ free(samples);
+ return 0;
+}
+
+int
+main(int argc, char **argv)
+{
+ double seconds = argc > 1 ? atof(argv[1]) : 5, vibrate_at = 0;
+ const void *keys[6], *values[6];
+ CFDictionaryRef settings;
+ CFURLRef url;
+ id recorder, error = NULL;
+ BOOL ok, vibrated = NO;
+ int tenths;
+
+ setvbuf(stdout, NULL, _IONBF, 0);
+ if (argc > 3 && strcmp(argv[2], "vibrate") == 0) {
+ vibrate_at = atof(argv[3]);
+ }
+ seconds = seconds < 1 ? 1 : seconds > 60 ? 60 : seconds;
+ if (!session_up()) {
+ return 1;
+ }
+ keys[0] = CFSTR("AVFormatIDKey");
+ values[0] = number('lpcm');
+ keys[1] = CFSTR("AVSampleRateKey");
+ values[1] = number(RATE);
+ keys[2] = CFSTR("AVNumberOfChannelsKey");
+ values[2] = number(1);
+ keys[3] = CFSTR("AVLinearPCMBitDepthKey");
+ values[3] = number(16);
+ keys[4] = CFSTR("AVLinearPCMIsFloatKey");
+ values[4] = kCFBooleanFalse;
+ keys[5] = CFSTR("AVLinearPCMIsBigEndianKey");
+ values[5] = kCFBooleanFalse;
+ settings = CFDictionaryCreate(NULL, keys, values, 6, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+ unlink(PATH);
+ url = CFURLCreateFromFileSystemRepresentation(NULL, (const UInt8 *)PATH, (CFIndex)strlen(PATH), false);
+ recorder = ((id (*)(id, SEL, id, id, id *))objc_msgSend)(send((id)objc_getClass("AVAudioRecorder"), "alloc"),
+ sel_registerName("initWithURL:settings:error:"), (id)url, (id)settings, &error);
+ if (recorder == NULL) {
+ printf("record_test: no AVAudioRecorder: %s\n", text(error));
+ return 1;
+ }
+ ((void (*)(id, SEL, BOOL))objc_msgSend)(recorder, sel_registerName("setMeteringEnabled:"), YES);
+ ok = ((BOOL (*)(id, SEL))objc_msgSend)(recorder, sel_registerName("prepareToRecord")) &&
+ ((BOOL (*)(id, SEL, double))objc_msgSend)(recorder, sel_registerName("recordForDuration:"), seconds);
+ printf("record_test: recording %.1f s into %s%s: %s\n", seconds, PATH, vibrate_at > 0 ? ", the motor at" : "",
+ ok ? "started" : "DOES NOT START");
+ if (!ok) {
+ return 1;
+ }
+ printf("record_test: meters (average/peak dB) every half second:");
+ for (tenths = 0; tenths < (int)(seconds * 10) + 5 && ((BOOL (*)(id, SEL))objc_msgSend)(recorder, sel_registerName("isRecording"));
+ tenths++) {
+ if (vibrate_at > 0 && !vibrated && tenths >= (int)(vibrate_at * 10)) {
+ printf("\n");
+ (void)vibrate();
+ vibrated = YES;
+ }
+ usleep(100000);
+ send(recorder, "updateMeters");
+ if (tenths % 5 == 4) {
+ printf(" %.0f/%.0f", ((float (*)(id, SEL, unsigned long))objc_msgSend)(recorder, sel_registerName("averagePowerForChannel:"), 0),
+ ((float (*)(id, SEL, unsigned long))objc_msgSend)(recorder, sel_registerName("peakPowerForChannel:"), 0));
+ }
+ }
+ printf("\n");
+ send(recorder, "stop");
+ usleep(300000);
+ return analyse(seconds, vibrate_at);
+}
diff --git a/userland/src/record_test.entitlements b/userland/src/record_test.entitlements
new file mode 100644
index 0000000..fba3b42
--- /dev/null
+++ b/userland/src/record_test.entitlements
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+ <key>com.apple.private.tcc.allow</key>
+ <array>
+ <string>kTCCServiceMicrophone</string>
+ </array>
+</dict>
+</plist>
diff --git a/xnu/files/bsd/dev/redwood_mic.c b/xnu/files/bsd/dev/redwood_mic.c
index ddd9d61..c07e930 100644
--- a/xnu/files/bsd/dev/redwood_mic.c
+++ b/xnu/files/bsd/dev/redwood_mic.c
@@ -61,11 +61,15 @@
#include <kern/thread.h>
#include <libkern/libkern.h>
#include <libkern/OSAtomic.h>
+#include <kern/kalloc.h>
#include <mach/mach_types.h>
+#include <miscfs/devfs/devfs.h>
#include <pexpert/pexpert.h>
+#include <sys/conf.h>
#include <sys/redwood_audio.h>
#include <sys/redwood_input.h>
#include <sys/systm.h>
+#include <sys/uio.h>
extern vm_offset_t ml_io_map(vm_offset_t phys_addr, vm_size_t size);
extern kern_return_t thread_terminate(thread_t thread);
@@ -105,6 +109,10 @@ say(const char *format, ...)
return length;
}
+/* A line that says all went as it should: not said again in iOS's later recordings (mic=4), where it is the same each time. */
+static bool quiet;
+#define note(...) do { if (!quiet) { say(__VA_ARGS__); } } while (0)
+
void
redwood_mic_quiesce(void)
{
@@ -176,7 +184,7 @@ get(struct block *b, const char *name, uint32_t offset)
b->base = ml_io_map(b->phys, b->size);
}
value = rd(b->base + offset);
- say("mic: %s %s (%#x) = %#x\n", b->name, name, b->phys + offset, value);
+ note("mic: %s %s (%#x) = %#x\n", b->name, name, b->phys + offset, value);
return value;
}
@@ -203,7 +211,7 @@ put(struct block *b, const char *name, uint32_t offset, uint32_t value, uint32_t
broken = true;
return false;
}
- say("mic: %s %s (%#x) <- %#x%s\n", b->name, name, b->phys + offset, value, check ? ", reads back" : "");
+ note("mic: %s %s (%#x) <- %#x%s\n", b->name, name, b->phys + offset, value, check ? ", reads back" : "");
return true;
}
@@ -263,8 +271,11 @@ command(const char *what, uint8_t service, uint32_t opcode, const void *payload,
return false;
}
if (answer->opcode == APR_BASIC_RSP_RESULT && answer->words[0] == opcode) {
- say("mic: %s: %s%s\n", what, answer->words[1] == 0 ? "done" : "REFUSED: ", answer->words[1] == 0 ? "" :
- dsp_error(answer->words[1]));
+ if (answer->words[1] == 0) {
+ note("mic: %s: done\n", what);
+ } else {
+ say("mic: %s: REFUSED: %s\n", what, dsp_error(answer->words[1]));
+ }
return answer->words[1] == 0 && wanted == 0;
}
if (wanted != 0 && answer->opcode == wanted) {
@@ -840,7 +851,7 @@ codec_put(uint16_t reg, uint8_t value, uint8_t check)
write_id = write_id < 14 ? write_id + 1 : 0;
swr_write(codec_device, reg, value, write_id);
if (check == 0) {
- say("mic: the codec's %#06x <- %#04x\n", reg, value);
+ note("mic: the codec's %#06x <- %#04x\n", reg, value);
return true;
}
if (!swr_read(codec_device, reg, &back) || (back & check) != (value & check)) {
@@ -848,7 +859,7 @@ codec_put(uint16_t reg, uint8_t value, uint8_t check)
broken = true;
return false;
}
- say("mic: the codec's %#06x <- %#04x, reads back\n", reg, value);
+ note("mic: the codec's %#06x <- %#04x, reads back\n", reg, value);
return true;
}
@@ -869,7 +880,7 @@ static void
broadcast(uint16_t reg, uint8_t value)
{
swr_write(0xf, reg, value, 0xf);
- say("mic: SoundWire, to all: %#06x <- %#04x\n", reg, value);
+ note("mic: SoundWire, to all: %#06x <- %#04x\n", reg, value);
sleep_ms(10); /* ("10 ms for the broadcast to complete", swrm_cmd_fifo_wr_cmd()) */
}
@@ -879,7 +890,7 @@ to_all(uint16_t reg, uint8_t value)
{
write_id = write_id < 14 ? write_id + 1 : 0;
swr_write(0xf, reg, value, write_id);
- say("mic: SoundWire, to all: %#06x <- %#04x\n", reg, value);
+ note("mic: SoundWire, to all: %#06x <- %#04x\n", reg, value);
}
/* wcd938x_bind(), wcd938x_set_micbias_data(), wcd938x_init_reg() */
@@ -969,7 +980,7 @@ port_config(uint8_t bank, bool first)
swr_write(codec_device, SWRS_DP_OFFSET_CONTROL_2_BANK(0, bank), 0, write_id);
write_id = write_id < 14 ? write_id + 1 : 0;
swr_write(codec_device, SWRS_DP_LANE_CONTROL_BANK(0, bank), 1, write_id);
- say("mic: the codec's data port 1, bank %u: channel 1 on, sample interval %u, offsets 0 0, lane 1\n", bank, codec_interval);
+ note("mic: the codec's data port 1, bank %u: channel 1 on, sample interval %u, offsets 0 0, lane 1\n", bank, codec_interval);
/* the master's port 1 */
return put(&tx_swr, "DP_PORT_CTRL (port 1): channel 1, offsets 0 0, interval 7", SWRM_DP_PORT_CTRL_BANK(1, bank),
0x01u << 24 | 0u << 16 | 0u << 8 | master_interval, 0xffffffff) &&
@@ -1029,7 +1040,7 @@ datapath_on(void)
(void)swr_read(codec_device, SWRS_DP_LANE_CONTROL_BANK(0, b), &v[3]);
(void)swr_read(codec_device, SWRS_SCP_FRAME_CTRL_BANK(b), &v[4]);
(void)swr_read(codec_device, SWRS_SCP_HOST_CLK_DIV2_CTL_BANK(b), &v[5]);
- say("mic: the codec's DP1, bank %u: channels %#x, interval %u, offset %u, lane %u; frame %#x, div2 %#x\n", b, v[0], v[1],
+ note("mic: the codec's DP1, bank %u: channels %#x, interval %u, offset %u, lane %u; frame %#x, div2 %#x\n", b, v[0], v[1],
v[2], v[3], v[4], v[5]);
}
{
@@ -1039,7 +1050,7 @@ datapath_on(void)
(void)swr_read(codec_device, SWRS_SCP_CONTROL, &control);
(void)swr_read(codec_device, 0x0100, &dp_int);
(void)swr_read(codec_device, 0x0102, &dp_ctl);
- say("mic: the codec's SCP int status %#x, control/status %#x; DP1 int status %#x, port control %#x; the master's DP1 "
+ note("mic: the codec's SCP int status %#x, control/status %#x; DP1 int status %#x, port control %#x; the master's DP1 "
"interrupt status %#x\n", status, control, dp_int, dp_ctl, swr_rd(0x1100));
}
return true;
@@ -1436,13 +1447,109 @@ dsp_off(void)
}
}
+/* ---- mic=4: the microphone for iOS ------------------------------------------------------------------- */
+
+/*
+ * What the microphone hears goes into a ring, and /dev/redwood-mic gives it to iOS's audio server
+ * (RedwoodAudio.driver's device "Codec", userland/src/audio_plugin.c): 16-bit samples, one channel,
+ * 48 kHz. The path is up only while the device is open (the audio server opens it when its input
+ * starts and closes it when it stops), and a read never waits: it gives what has come, keeping the
+ * reader about 40 ms behind the DSP (it comes in 20 ms periods), and nothing until that much is
+ * there; the audio server makes up the rest with silence.
+ */
+#define RING_FRAMES 16384 /* 341 ms; a power of two */
+#define RING_KEEP 1920 /* 40 ms: how far behind the DSP a reader is kept */
+#define RING_MOST 4800 /* 100 ms: more than this waiting, and the oldest is skipped */
+
+static int16_t *ring;
+static volatile uint64_t ring_written; /* frames put into the ring since the device was made */
+static uint64_t ring_read; /* frames taken from it (one reader: the audio server) */
+static bool ring_primed; /* the reader is RING_KEEP behind; false after it ran dry */
+static uint64_t ring_skipped, ring_dry; /* frames skipped, reads that found too little: said when iOS stops */
+static volatile uint32_t ios_wants; /* the device is open */
+static volatile bool stopping; /* the run ends (redwood_mic_dsp_down()) */
+
+static void
+ring_put(const int16_t *samples, uint32_t count)
+{
+ uint64_t at = ring_written;
+
+ for (uint32_t i = 0; i < count; i++) {
+ ring[(at + i) % RING_FRAMES] = samples[i];
+ }
+ __atomic_store_n(&ring_written, at + count, __ATOMIC_RELEASE);
+}
+
+static int
+mic_dev_read(__unused dev_t dev, struct uio *uio, __unused int ioflag)
+{
+ uint64_t written = __atomic_load_n(&ring_written, __ATOMIC_ACQUIRE), avail, want;
+ int error = 0;
+
+ if (ring == NULL || uio_resid(uio) < 2) {
+ return 0;
+ }
+ want = (uint64_t)uio_resid(uio) / 2;
+ avail = written - ring_read;
+ if (avail > RING_MOST) {
+ ring_skipped += avail - RING_KEEP;
+ ring_read = written - RING_KEEP;
+ avail = RING_KEEP;
+ }
+ if (!ring_primed) {
+ if (avail < RING_KEEP) {
+ return 0;
+ }
+ ring_primed = true;
+ }
+ if (avail < want) {
+ ring_dry++;
+ ring_primed = false;
+ }
+ while (want > 0 && avail > 0 && error == 0) {
+ uint64_t at = ring_read % RING_FRAMES, n = want < avail ? want : avail;
+
+ n = n < RING_FRAMES - at ? n : RING_FRAMES - at;
+ error = uiomove((caddr_t)&ring[at], (int)(n * 2), uio);
+ ring_read += n;
+ want -= n;
+ avail -= n;
+ }
+ return error;
+}
+
+static int
+mic_dev_open(__unused dev_t dev, __unused int flags, __unused int type, __unused struct proc *p)
+{
+ ios_wants = 1;
+ return 0;
+}
+
+/* (on the last close) */
+static int
+mic_dev_close(__unused dev_t dev, __unused int flags, __unused int type, __unused struct proc *p)
+{
+ ios_wants = 0;
+ return 0;
+}
+
+static const struct cdevsw mic_cdevsw = {
+ .d_open = mic_dev_open, .d_close = mic_dev_close, .d_read = mic_dev_read, .d_write = eno_rdwrt,
+ .d_ioctl = eno_ioctl, .d_stop = eno_stop, .d_reset = eno_reset, .d_select = eno_select,
+ .d_mmap = eno_mmap, .d_strategy = eno_strat, .d_type = 0
+};
+
/* ---- listening ---------------------------------------------------------------------------------------------- */
static uint32_t mic_secs = 10;
-/* the stream run, read for mic_secs: how loud it is, every second; into the recording with rec_sound_mic=1 */
+/*
+ * The stream run, read for mic_secs (for_ios: while iOS has the device open): how loud it is, every
+ * second (for iOS: the first three, then every 30th); into the recording with rec_sound_mic=1; for
+ * iOS into the ring.
+ */
static void
-listen(void)
+listen(bool for_ios)
{
uint32_t run[3] = { 0, 0, 0 }, frames = 0, seconds = 0, peak = 0, periods = 0, empty = 0;
int64_t sum = 0;
@@ -1454,6 +1561,7 @@ listen(void)
struct redwood_apr_answer answer;
read_ready = 0;
+ reads_done = read_errors = 0;
if (!redwood_adsp_apr(APR_SVC_ASM, MIC_STREAM_PORT, 0, ASM_SESSION_CMD_RUN_V2, run, sizeof(run), APR_WAIT_MS, &answer) ||
answer.opcode != APR_BASIC_RSP_RESULT || answer.words[1] != 0) {
say("mic: the session, run: REFUSED OR NO ANSWER (%#x %#x)\n", answer.opcode, answer.words[1]);
@@ -1466,7 +1574,11 @@ listen(void)
return;
}
}
- say("mic: LISTENING: %u reads of 20 ms given to the DSP; for %u s\n", MIC_PERIODS, mic_secs);
+ if (for_ios) {
+ say("mic: LISTENING for iOS: %u reads of 20 ms given to the DSP\n", MIC_PERIODS);
+ } else {
+ say("mic: LISTENING: %u reads of 20 ms given to the DSP; for %u s\n", MIC_PERIODS, mic_secs);
+ }
for (;;) {
absolutetime_to_nanoseconds(mach_absolute_time() - began, &now);
elapsed_ms = now / NSEC_PER_MSEC;
@@ -1482,7 +1594,7 @@ listen(void)
redwood_haptic_pretend(0);
tap = 2;
}
- if (elapsed_ms >= mic_secs * 1000ull || broken) {
+ if ((for_ios ? (!ios_wants || stopping) : elapsed_ms >= mic_secs * 1000ull) || broken) {
break;
}
if (!(read_ready & (1u << next))) {
@@ -1514,6 +1626,9 @@ listen(void)
peak = a > peak ? a : peak;
}
frames += got;
+ if (for_ios) {
+ ring_put(samples, got);
+ }
if (redwood_audio_recording_mic()) {
for (uint32_t i = 0; i < got; i += 240) {
uint32_t n = got - i < 240 ? got - i : 240;
@@ -1548,9 +1663,12 @@ listen(void)
db10 = tenths - (int)((32768 - r) * 60 / 16384);
}
seconds++;
- say("mic: second %u: %u frames (%u periods, %u empty), level %d.%d dBFS (rms %u), peak %u, mean %lld; reads %u, "
- "errors %u%s%s\n", seconds, frames, periods, empty, db10 / 10, db10 < 0 ? -db10 % 10 : db10 % 10, rms, peak,
- sum / (int64_t)frames, reads_done, read_errors, unmuted ? "" : " (muted)", settled ? "" : " (settling)");
+ if (!for_ios || seconds <= 3 || seconds % 30 == 0) {
+ say("mic: second %u: %u frames (%u periods, %u empty), level %d.%d dBFS (rms %u), peak %u, mean %lld; "
+ "reads %u, errors %u%s%s\n", seconds, frames, periods, empty, db10 / 10, db10 < 0 ? -db10 % 10 : db10 % 10,
+ rms, peak, sum / (int64_t)frames, reads_done, read_errors, unmuted ? "" : " (muted)",
+ settled ? "" : " (settling)");
+ }
frames = periods = empty = peak = 0;
sum = 0;
squares = 0;
@@ -1571,38 +1689,123 @@ undo(void)
clocks_off();
}
+/* Everything up to the stream's run, in a recording's order; false (and `broken') if any of it fails. */
+static bool
+path_up(void)
+{
+ if (!clocks_on()) {
+ say("mic: the clocks were not all given: the blocks are not touched\n");
+ return false;
+ }
+ if (!reset_release() || !pins_on() || !tx_clocks_on() || !master_on()) {
+ return false;
+ }
+ sleep_ms(5); /* ("5 ms for SoundWire's auto-enumeration", wcd938x_bind()) */
+ if ((codec_device = codec_wait()) == 0) {
+ return false;
+ }
+ swr_write(0xf, SWRS_SCP_INT_STATUS_MASK_1, 0x04, 0xf); /* (swrm_runtime_resume(): broadcast) */
+ sleep_ms(10);
+ if (!quiet) {
+ codec_look();
+ }
+ if (level < 3) {
+ return true;
+ }
+ /* the stream and path, the port's format and start, the codec's widgets */
+ return bolero_look() && codec_init() && dsp_path_on() && dsp_port_on() && dec1_on() && (!adc_on || adc1_on()) &&
+ datapath_on();
+}
+
+/*
+ * mic=4: the path up whenever iOS opens /dev/redwood-mic, down when it closes it; after three
+ * recordings that broke off, no more until the run ends.
+ */
+static void
+for_ios(void)
+{
+ int major = cdevsw_add(-1, &mic_cdevsw);
+ unsigned recordings = 0, failures = 0;
+
+ ring = kalloc_data(RING_FRAMES * sizeof(int16_t), Z_WAITOK | Z_ZERO);
+ if (ring == NULL || major < 0 ||
+ devfs_make_node(makedev(major, 0), DEVFS_CHAR, UID_ROOT, GID_WHEEL, 0666, "redwood-mic") == NULL) {
+ say("mic: /dev/redwood-mic cannot be made\n");
+ return;
+ }
+ say("mic: THE MICROPHONE IS IOS'S (/dev/redwood-mic) from here on, until the run ends: it listens only while iOS records\n");
+ while (!stopping) {
+ uint64_t began, ns;
+ bool failed;
+
+ if (!ios_wants) {
+ sleep_ms(20);
+ continue;
+ }
+ lck_mtx_lock(&mic_lock);
+ if (stopping) {
+ lck_mtx_unlock(&mic_lock);
+ break;
+ }
+ recordings++;
+ quiet = recordings > 1;
+ ring_primed = false;
+ ring_skipped = ring_dry = 0;
+ ring_read = __atomic_load_n(&ring_written, __ATOMIC_ACQUIRE);
+ began = mach_absolute_time();
+ say("mic: iOS records (%u): the path up%s\n", recordings, quiet ? " (the lines that say all went well are not said again)" :
+ "");
+ if (path_up()) {
+ listen(true);
+ }
+ failed = broken;
+ absolutetime_to_nanoseconds(mach_absolute_time() - began, &ns);
+ say("mic: iOS's recording %u %s after %llu.%llu s; last: %s; %llu frames skipped as too late, %llu reads found too little\n",
+ recordings, failed ? "BROKE OFF" : "ended", ns / NSEC_PER_SEC, ns % NSEC_PER_SEC / (NSEC_PER_SEC / 10), last_write,
+ ring_skipped, ring_dry);
+ undo();
+ lck_mtx_unlock(&mic_lock);
+ if (failed) {
+ broken = false;
+ if (++failures >= 3) {
+ say("mic: three recordings broke off: the microphone stays off until the run ends\n");
+ break;
+ }
+ /* (not again until iOS has closed the device and opened it again) */
+ while (ios_wants && !stopping) {
+ sleep_ms(20);
+ }
+ }
+ }
+}
+
static void
mic_thread(__unused void *parameter, __unused wait_result_t result)
{
- lck_mtx_lock(&mic_lock);
say("mic: level %u: %s\n", level, level == 1 ? "a look, after the LPASS's votes and clocks; nothing written to the codec" :
level == 2 ? "the codec brought up to answer on SoundWire, nothing of it set; then all undone" :
- "the main microphone, as Android records from it, listened to; then all undone");
- if (!clocks_on()) {
- say("mic: the clocks were not all given: the blocks are not touched\n");
- } else if (level == 1) {
- sleep_ms(10);
- look();
- } else if (reset_release() && pins_on() && tx_clocks_on() && master_on()) {
- sleep_ms(5); /* ("5 ms for SoundWire's auto-enumeration", wcd938x_bind()) */
- if ((codec_device = codec_wait()) != 0) {
- swr_write(0xf, SWRS_SCP_INT_STATUS_MASK_1, 0x04, 0xf); /* (swrm_runtime_resume(): broadcast) */
- sleep_ms(10);
- codec_look();
- if (level >= 3) {
- /* in a recording's order: the stream and path, the port's format and start, the codec's widgets, the run */
- if (bolero_look() && codec_init() && dsp_path_on() && dsp_port_on() && dec1_on() && (!adc_on || adc1_on()) &&
- datapath_on()) {
- listen();
- }
- say("mic: %s; last: %s\n", broken ? "STOPPED" : "listened", last_write);
+ level == 3 ? "the main microphone, as Android records from it, listened to; then all undone" :
+ "the main microphone for iOS (/dev/redwood-mic), up while iOS records");
+ if (level == 4) {
+ for_ios();
+ } else {
+ lck_mtx_lock(&mic_lock);
+ if (level == 1) {
+ if (clocks_on()) {
+ sleep_ms(10);
+ look();
+ } else {
+ say("mic: the clocks were not all given: the blocks are not touched\n");
+ }
+ } else {
+ if (path_up() && level >= 3) {
+ listen(false);
}
+ say("mic: %s; last: %s\n", broken ? "STOPPED" : level >= 3 ? "listened" : "done", last_write);
}
- } else {
- say("mic: stopped; last: %s\n", last_write);
+ undo();
+ lck_mtx_unlock(&mic_lock);
}
- undo();
- lck_mtx_unlock(&mic_lock);
running = false;
say("mic: done\n");
thread_terminate(current_thread());
@@ -1616,7 +1819,7 @@ redwood_mic_dsp_up(void)
if (!PE_parse_boot_argn("mic", &level, sizeof(level)) || level == 0) {
return;
}
- level = level > 3 ? 3 : level;
+ level = level > 4 ? 4 : level;
PE_parse_boot_argn("mic_secs", &mic_secs, sizeof(mic_secs));
PE_parse_boot_argn("mic_input", &smic_input, sizeof(smic_input));
PE_parse_boot_argn("mic_adc", &adc_on, sizeof(adc_on));
@@ -1635,6 +1838,7 @@ redwood_mic_dsp_up(void)
void
redwood_mic_dsp_down(void)
{
+ stopping = true;
if (running) {
lck_mtx_lock(&mic_lock);
undo();