collector: 更新采集工程至 v1.3.5（RGB 断联根因＝DECXIN 停在等时档 alt7 每 68~116 秒静默停摆，改自适应档位：libuvc 新增 uvc_set_altsetting_override() 运行时接口、起始取最保守档、连停 2 次或连开不起来 3 次自动降档并落盘；camera-service 加静默卡死自愈与 SIGTERM 有界收尾；夹爪扫描配对从 USB 根端口改走 ESP32 NVS 序列号；s80c 上色工具修隔帧重复。另：不含误提交的 rec003.zip）

collector/.gitignore

@@ -28,6 +28,8 @@ venv_lite/
 .claude/
 keypoints_output/
 exports/
+# 本地取回的录制素材与上色产物（双目原视频等，体积大且属外部数据）
+rec001(1)/
 tools/weights/
 wheels/          # scripts/pack_wheels.py 生成的离线部署包（不入库，拷给客户用）
 imgui.ini

collector/README.md

@@ -1,6 +1,6 @@
 # collector — Multimodal Data Acquisition SDK · 多模态数据采集 SDK
 
-![Version](https://img.shields.io/badge/version-1.3.4-blue)
+![Version](https://img.shields.io/badge/version-1.3.5-blue)
 ![Python](https://img.shields.io/badge/python-3.12-blue)
 ![License](https://img.shields.io/badge/license-TBD-lightgrey)
 
@@ -361,6 +361,128 @@ are documented in [docs/index.md](docs/index.md#开发约定).
 
 ### Changelog
 
+- **v1.3.5** — the camera service heals itself, and gripper scan pairing moved
+  from USB root ports to NVS serials.
+  **Cameras:** the UVC cameras (DECXIN `1bcf:2d4f` plus two Sightac `0c45:636f`)
+  can wedge silently with no process touching them — on 2026-09-15 the right
+  Sightac was streaming normally at 21:53 and simply refused to start at 09:24,
+  with no usbfs or uvcvideo message in between and the machine awake all night.
+  What the user sees ("RGB shows only the first frame", "camera-service did not
+  obtain valid MJPG frames from all cameras within the time limit") is really a
+  failure to recover, not a failure to stay up. Two different wedges need two
+  different cures: a **stall** (stream running, `received` freezes, not a single
+  kernel message, 6–82 s at random, load-correlated) recovers from rebuilding
+  the libusb context alone (6/6 and 5/5 measured — a USB reset is a wasted
+  cost), while a **hard failure** (`uvc_start_streaming failed: I/O error`,
+  `UVC format/interface negotiation failed: Invalid mode`, or
+  `negotiated_payload` alternating 3072/0) does not (9 consecutive attempts
+  failed; the device firmware is wedged) and only a USB reset / re-enumeration
+  clears it. Added a 3-second stall watchdog (`STREAM_STALL_TIMEOUT_SECONDS`,
+  4 s for the first frame); stalls rebuild the libusb context, hard failures
+  escalate to a USB reset after **2 consecutive** attempts (capped at
+  `USB_RESET_LIMIT` 3, since without a cap a genuinely dead device would reset
+  every 2 seconds and pin the two neighbours on the same hub), and a stall
+  clears that counter so stalls can never add up into a spurious reset. The
+  reset now happens **before** `uvc_stop_streaming` (`teardown_failed_open`):
+  on a wedged device `uvc_stop_streaming` waits for isochronous transfers that
+  never return, which measurably burns the client's 2-second grace period and
+  gets the process SIGKILLed mid-teardown, leaving the device on an active alt
+  setting so the next start fails the same way. Every threshold is derived
+  backwards from the client's `SERVICE_START_TIMEOUT_S = 10.0` (second failure
+  at t≈2 s → reset → frames by t≈3 s); the old "reset after 20 s of zero
+  frames" gate could never fire in a real start, and was attached to the
+  zero-frame branch the observed `I/O error` never reaches. Measured reset
+  semantics: on a healthy device it is an in-place port reset (kernel logs
+  `reset high-speed USB device number N`, devnum unchanged); on a wedged device
+  the device drops and re-enumerates (devnum changes) — that is what heals it,
+  and libusb reports `rc=-4 (No such device)` during that window, which is
+  misleading but harmless. Also fixed the per-second fps reporting baseline
+  (it counted from zero, so a restart reported the whole process lifetime as
+  one window: 164/207/251 fake fps).
+  **RGB disconnects, root cause:** self-healing was only half the story — the
+  camera still dropped out afterwards. DECXIN stalls silently every 68–116 s
+  while running the high-bandwidth isochronous setting alt7, on **both**
+  controllers tested (AMD `1022:43fc`/PCI `0000:0a:00.0` and
+  `1022:15b7`/`0000:74:00.4`). The mechanism is **not determined**: measured
+  throughput at the moment of the stalls was only 1.66 MB/s mean / 2.63 peak,
+  far under the 10.24 MB/s alt7 reserves, so "not enough bandwidth" does not
+  explain it. alt6 holds, and both rungs deliver **identical 30.00 fps**, so
+  alt7's extra per-frame headroom (327680 vs 241664 B) buys nothing observable.
+  Two earlier conclusions are retracted: *"alt7 is fine on bus 1"* — that
+  supposedly clean leg never ran at alt7 at all, because the old binary's ini
+  fields were inert and the service merely echoed them, so the only trustworthy
+  indicator of a leg's real setting is the `[LIBUVC-QUIRK] ... alt=N payload=M
+  ... xfers=` line; and the controller-specific claim that followed from it.
+  `forced_altsetting`/`forced_payload` are now **authoritative** through a new
+  libuvc runtime API `uvc_set_altsetting_override()` (declared in `libuvc.h`,
+  implemented in `device.c`) — before this they were only validated and
+  printed, so editing the ini changed nothing, which is very easy to misread.
+  The starting rung is chosen in Python, not hardcoded per machine: learned >
+  the table's most conservative rung > the scanner's preferred one, because the
+  rack's bus is not permanent. A ladder then steps down one rung and persists
+  the conclusion under `vid:pid × controller PCI path × camera serial` after 2
+  consecutive stalls or 3 consecutive failed opens (the latter covers a
+  setting that will not fit at STREAMON, where the stream never starts and the
+  stall path can never fire); `CLEAN_RUN_SECONDS = 300` clears the stall
+  counter. A downgrade must clear **both** counters — the thresholds are
+  equality tests, so a counter left standing on its threshold never fires
+  again and the failed-open path would jam after a single step. Both log lines
+  capture the count *before* the downgrade clears it. The scanner truthfully
+  reports the descriptor's preferred rung (alt7); the app checks it is *any*
+  rung of the ladder and refuses only on a genuine desync. The C source and its
+  build recipe moved into `core/gripper/camera_service_src/` (`./build.sh` is
+  the single entry point), and `--test` now runs `ctest` — the ladder test was
+  registered with `add_test` but had never actually been executed, and the
+  jam-bug above fell exactly inside what it should have covered. Verified on
+  hardware: forced alt7 stalled at 78 s and 116 s, the service logged the
+  downgrade and recovered to alt6 for 169 s at 30 fps with zero stalls; the
+  app-generated ini (alt6 default) then ran **600 s across three legs with 0
+  stalls / 0 rebuilds / 0 failed opens / 0 resets** (17513/17496/17487 frames),
+  and a post-install 300 s regression on the deployed binary was clean too. The
+  ladder test was reverse-verified as non-vacuous: removing the counter reset
+  makes it abort.
+  **Grippers:** ported the scan chain from the delivery package
+  `设备扫描逻辑与程序_20260914`. Pairing used to go through USB root
+  ports/controllers — a premise that was simply wrong, since the Fays is a
+  USB3/FT602 device on its own 5000M bus and never shared a root with the
+  UVC/ESP32 devices. The chain is now: UVC group → the unique ESP32 (path
+  starting `bus-outer.`) → send `QF` over serial to read the Fays serial bound
+  in its NVS → match against the official SDK's enumerated `device.serial`,
+  with a clear refusal when any step is not unique and no fallback to guessing
+  by port or enumeration order. The SDK probe is preceded by a
+  `validate_fays_superspeed` pre-check and then enumerates serials fast
+  (`--serial-only-fast`; a timeout now decodes stdout/stderr and appends the
+  last 20 lines instead of reporting a bare timeout). Dual-rig runs skip a
+  device another rig holds instead of claiming it. On the serial side the fixed
+  boot delay became a 2-second polling `?` handshake, the port is opened
+  `exclusive=True`, and `QF` (query) / `WF:<serial>` (write) commands were
+  added; `GripperSerial.send()` looked commands up by their first character
+  only (`[:1]`), so `"QF"` could never match its own expected list. Prerequisite:
+  the ESP32 firmware must understand `QF`/`WF:` — the current `online/esp32_proc`
+  firmware does not, and will fail closed with "查询 Fays 序列号失败: ERR".
+  Added the offline self-check `tools/tests/test_gripper_fays_pairing.py`.
+  **s80c colorize tool:** fixed a duplicated-every-other-frame bug in
+  `tools/s80c_arm_convert/convert_arm_dataset.py` (an independent fix committed
+  after v1.3.4). `pooled_episodes_v1` recordings write **two rows per frame**
+  (`frame_index` = 0,0,1,1,…, with identical `timestamp`/`hardware_ns` in both
+  rows) while the video has one frame; the tool used the row count as the frame
+  count and then indexed `hw_ns[i]` by video frame number, so every timestamp
+  was sent twice — and the offline ISP reuses the previous output for a
+  duplicate timestamp, which is what duplicated every other frame. Measured on
+  rec001's lossless output: 394 of 833 frames byte-identical to their
+  predecessor, all 394 at odd positions (the second of each timestamp pair),
+  versus 0 in the source video. The same root cause also **halved the IMU
+  sidecar** — `hw_ns[:n_frames]` only reached the 417th timestamp and every
+  later IMU sample was dropped by the "later than the last frame" rule, leaving
+  416 rows / 13.8 s; after the fix, 832 rows / 27.7 s against a 27.8 s video.
+  Redundant rows are now folded by `frame_index`, but **only when every row
+  under that index has identical `timestamp` and `hardware_ns`**; otherwise it
+  warns and leaves the data untouched. Of the 142 parquets carrying
+  `frame_index`, 129 already had one row per frame (no-op), 1 was genuinely
+  redundant (rec001, 1666 rows → 833 frames), and 12 had differing timestamps
+  between rows (folding would lose them, so they are warn-only). The colorize
+  chain itself is untouched: same config, same offline ISP, `--sdk-wb-auto` as
+  before, with grey-world gains bit-identical to the pre-fix run.
 - **v1.3.4** — a newly plugged-in gripper now generates its own runtime
   calibration and connects, with no manual step. Previously onboarding a new
   Fays S80M took two manual steps — click `device_setup` on the gripper's host
@@ -833,6 +955,47 @@ i18n 文案经 `tr()` 翻译、PyQt5 信号参数用 `object` 封送大整数、
 
 ### 更新记录
 
+- **v1.3.5** — 相机服务能自愈了；夹爪扫描配对从 USB ��端口改走 NVS 序列号。
+  **相机侧**：UVC 相机（DECXIN `1bcf:2d4f` 与两个 Sightac `0c45:636f`）会**静默
+  卡死、且不需要任何进程碰它**——2026-09-15 实证右目 Sightac 是自己夜里坏的
+  （21:53 还在正常推流，09:24 启动就坏，中间没有任何进程打开过它、内核无
+  usbfs/uvcvideo 消息，机器整夜没睡）。用户看到的「RGB 只剩第一帧」「未在限定
+  时间取得全部相机的有效 MJPG 帧」，根子是**服务不会自愈**，不是**服务会倒**。
+  两种卡死要分开治：**停摆**（开着流突然不出帧、`received` 冻住、内核一条消息
+  都没有，6~82 秒随机、与负载正相关）**重建 libusb 上下文就够**（实测 6/6、5/5
+  全恢复，USB 复位是白付的代价）；**开不起来**（`uvc_start_streaming failed:
+  I/O error`、`UVC format/interface negotiation failed: Invalid mode`、
+  `negotiated_payload` 在 3072↔0 之间跳）**重建上下文救不回来**（实测连试 9 次
+  全败，设备固件侧卡死了），只有 USB 复位/重枚举能洗。新增 3 秒停滞看门狗
+  （`STREAM_STALL_TIMEOUT_SECONDS`，首帧 4 秒）；停摆（`rc>0`）重建 libusb
+  上下文；开不起来（`rc<0`）**连续 2 次**升级成 USB 复位，`USB_RESET_LIMIT` 3 次
+  封顶（设备真坏了时不设上限会变成每 2 秒复位一次、把同 Hub 的另外两路一直按在
+  地上），而停摆会清零该计数，免得几次停摆凑数误触发复位去打扰邻居。**复位要抢在
+  `uvc_stop_streaming` 之前**（`teardown_failed_open`）——卡死设备上
+  `uvc_stop_streaming` 会一直等它那批永远回不来的等时传输，实测能把客户端那 2 秒
+  宽限耗光而被 SIGKILL，进程死在这中间、设备就停在激活的 alt setting 上，下一轮
+  照样起不来（09:24 的日志正是断在 startup failed 与 usb reset 之间）。所有阈值由
+  客户端窗口 `SERVICE_START_TIMEOUT_S = 10.0` 倒推：第 2 次失败在 t≈2 秒触发复位、
+  t≈3 秒就能出帧；旧的「重开 20 秒零帧才复位」在真实启动场景**永远够不到**，且只
+  挂在零帧分支上。复位语义实测：打在**健康**设备上是原地端口复位（devnum 不变），
+  打在**卡死**设备上是掉线重枚举（devnum 变了）**这才会好**，libusb 在那窗口里返回
+  `rc=-4 (No such device)` 是报错但事办了。真机验证：第 1 次失败不复位、第 2 次
+  `usb reset: rc=0 (Success)`、打满 3 次后停手；三路 90 秒回归 0 停摆 0 误复位
+  （2694/2683/2684 帧 ≈29.9fps）；SIGTERM 退出 1.16 秒，不超客户端 2 秒宽限。
+  **夹爪侧**：移植交付包「设备扫描逻辑与程序_20260914」。配对从 **USB 根端口/
+  控制器**改走 **NVS 序列号**——旧规则（外加「同一 USB2 总线出现双 rig 就拒扫」）
+  的前提就是错的：Fays 是 USB3/FT602 挂在配套的 5000M 总线上，跟 UVC/ESP32 本来
+  就不共根，只能靠猜。新链路：UVC 组 → 唯一 ESP32（`bus-outer.` 开头）→ 串口发
+  `QF` 读它 NVS 里绑定的 Fays 序列号 → 与官方 SDK 枚举出的 `device.serial` 比对，
+  任一步不唯一就明确拒绝，不再按端口或枚举顺序猜。SDK 探测前先做超速预检，再以
+  `--serial-only-fast` 快速枚举序列号（超时不再只报一句 timeout，解码
+  stdout/stderr 并附最后 20 行）；双 rig 会「在用时跳过」另一 rig 正持有的设备
+  而不是占用。串口侧：固定 2 秒死等改成轮询 `?` 握手，端口加 `exclusive=True`，
+  新增 `QF` 查询 / `WF:<serial>` 写入；顺带修 `send()` 只拿首字符查命令表
+  （`[:1]`）导致 `"QF"` 永远匹配不上自己期望表的 bug。**前置条件：ESP32 固件必须
+  认识 `QF`/`WF:`，当前 `online/esp32_proc` 的固件还不认识，会失败关闭并报
+  「查询 Fays 序列号失败: ERR」，需先烧固件。** 新增离线自检
+  `tools/tests/test_gripper_fays_pairing.py`。
 - **v1.3.4** — 新夹爪接入即自动生成运行标定并连接，不再需要任何人工步骤。
   此前接入一只新 Fays S80M 要人工两步——先在夹爪上位机点 `device_setup`、
   再在采集机跑 `tools/import_gripper_calibration.py` 导入，漏掉任一步主程序

collector/config/__init__.py

@@ -3,4 +3,4 @@
 版本号集中定义于此：settings.APP_VERSION 及其他模块均从这里取值。
 """
 
-__version__ = "1.3.4" # 新夹爪接入即自动生成运行标定并连接（Fays S80M）：此前接入一只新夹爪要人工两步——先在夹爪上位机点 `device_setup`、再在采集机跑 `tools/import_gripper_calibration.py` 导入，漏掉任一步主程序直接拒绝启动（「当前 Fays 缺少运行标定文件…请先在夹爪上位机中运行 device_setup」）；现在 `SingleFaysLease.acquire()` 发现 per-serial YAML 缺失时，就在设备锁内调厂商导出程序从**这只夹爪自身**读出厂标定、生成 SDK YAML 与 ORB YAML（鱼眼 `stereoRectify` 求 P1/R1 + IMU 外参 `T_b_c1` + 探针读五项噪声/频率），复核落盘路径后直接连上，已有标定走 `isfile` 快路径（启动零额外开销、不碰设备）——这两个文件是**逐设备**出厂标定不可跨设备复用（实测 098/099 三组全不同），只能现场读；设备面板夹爪条目右键加「重新读取出厂标定」（录制中禁用，标定前自动关该夹爪、完成后开回），`tools/import_gripper_calibration.py` 加 `--generate`（旧文件先备份 `.bak_<时间戳>`）供命令行强制重生成；顺带修掉生成产物第 3 行的出处注释——厂商模板写死指向 `3500000261870088`，照抄会让每只新夹爪的 IMU 外参都被记成「取自另一台设备」，现改写成本机序列号（历史产物不动）。承接 v1.3.3 的力矩阵/触觉力与 RGB 视频的时间戳对齐：**力侧此前完全没有时间戳**——同一行里的 RGB 帧和力样本不是同时刻采集的，RGB 走外部帧源队列取队头最旧帧、力/矩阵走 latest-wins 单槽取当下最新，于是「行号相同」≠「时刻相同」，力恒领先 RGB 且领先量随录制时长增长（RGB 源 30.84fps vs 写线程 30fps，实测约 1 帧/秒，下游观测到的滞后 3 帧就是这么来的），力矩阵走独立泵线程还与 3 向量力各记各的时刻。修法是让每行自描述：`tactile_ready` 加第 5 个载荷 `capture_ns`（在 SDK 回调入口取），`pipeline.write_tactile_force/_force_matrix` 落成独立的 `observation.gripper_{side}_force_ns` / `_force_matrix_ns` 稀疏 int64 列（与 `hardware_ns` 同宿主单调钟时基，features 里声明 `encoding: host_monotonic_ns`），下游按时间取最近邻即可还原真实配对，精度上界=半个力样本间隔；顺带修 `rgb_frame_ready`/`stereo_frame_ready` 的 `pyqtSignal(int)` 把 `time.monotonic_ns()` 按 C++ qint32 静默截断成负数（每 2.147s 翻符号），改 `object` 封送——这也解释了此前用 `hardware_ns` 解回卷时凭空造出上百帧假漂移、把"中位 5.8 帧 / 最大 ±80 帧"报成对齐误差（真值是 ~3 帧，正确规则是**无符号**：单调钟 + FIFO 消费 ⇒ 真步长恒非负）；新增 `scripts/align_modalities.py` 处理端最近邻对齐工具，对 v1.3.3 之前录的 episode 明确报「无法对齐（只能重录）」而不用增长率去猜。承接 v1.3.2 的 SLAM 陈旧帧入库前拦截与轨迹显示深拷贝修复。：桥接按「连续回退次数」判定——单帧脏读丢弃、连丢 30 帧才判定时钟真跳变并换基准放行（此前每一帧回退都会让核心库清空 IMU 队并重建地图、位姿停发 0.2–1.34 s，静止时更久），新增 `[TIME_DROP]`/`[TIME_REBASE]` 现场行并**无条件**打进 GUI 日志（此前落进未匹配行被 50 条上限吃掉——实测原生日志 4 次回退、GUI 日志 0 条，真出事时反而看不见），且带 `seq`/`prev_seq` 对比结论以区分「SDK 乱序投递 / 重复投递同一帧 / 帧配了旧时间戳」三种成因（时间戳上三者长得一模一样，对策完全不同）；逐秒遥测 `[FPS_DATA]` 改「只在异常时出声」（健康静默、进入异常与恢复各一行、持续异常每 30 s 重复，全量逐秒流仍在原生日志里），并修 `wait_sdk_ready` 就绪门被**粘滞** `state.error` 锁死——任何信息性输出（如 ld.so 的 `cannot be preloaded ... ignored.`）都会让标定明明已完成的这一次返回 False、报出误导的「未等到 [FAYS-CALIB] 标记」（2026-09-10 18:32 假超时事故，文案白名单 + 去掉粘滞判断双管修）；原生日志在 runtime 目录 `rmtree` 之前留档到 `logs/slam_native/`（保留最近 20 份），修「一次干净退出的会话其原生日志不可恢复」——排查 SLAM 崩溃时唯一的证据曾随目录一起被删；轨迹显示去掉 Qt 主线程上的整条深拷贝（正是这次拷贝让 `_rendered_trajectory is traj` 判等恒为假、每个位姿都在主线程复制随会话线性增长的点列，即「画一段时间后帧率变低」的直接原因），显示上限 400→6000，并以向量化投影 + 一次 `drawPolyline` 绘制，修「十几秒后轨迹显出折角」（降采样按 stride 翻倍使顶点数恒落 [上限/2, 上限]，上限 400 时每段跨 67 ms 且随 stride 每翻一倍继续变粗��观感像 SLAM 出点变慢而数据一直满 30 Hz，是绘制侧丢的）；RGB 外部队列在录制开始/结束/中止三个边界排空，修「上一段残留 + 本段启动窗口累积被写成新视频开头」（实测每段开头约 28 帧与上一段 episode 末帧逐帧匹配，队列满时还占 ~110 MB/槽）；任务进度只上报后端当前任务列表里存在的任务（本地自建任务平台没这个项目，上报必被拒 400），且后端该项目口径为 `"sessions"`（从没收到过任何上报）时首次送本机**全量**当基线——只送增量会把后端计数从 session 数砸成增量本身（现场：3/3/3 的项目再录一条变 1）。承接 v1.3.1 的力矩阵 5 档落盘与 SLAM 停落 slam_pose 列。
+__version__ = "1.3.5" # 夹爪扫描配对改走 ESP32 NVS 序列号 + camera-service 自愈（两个都是「不恢复」的毛病，不是「会坏」的毛病）。相机侧：UVC 相机（DECXIN 1bcf:2d4f + 两个 Sightac 0c45:636f）会**静默卡死且不需要任何进程碰它**，用户看到的「RGB 只剩第一帧」「camera-service 未在限定时间取得全部相机的有效 MJPG 帧」根子是**服务不会自愈**——实证 2026-09-15 右目 Sightac 是自己夜里坏的（21:53 还在正常推流，09:24 启动就坏，中间没有任何进程打开过它、内核无 usbfs/uvcvideo 消息，机器整夜没睡、14.9 万条内核日志里查不到肇事者）→ 别再去查「谁把它弄脏的」，服务必须能自愈。两种卡死要分开治：**停摆**（开着流突然不出帧、`received` 冻住、内核一条消息都没有，6~82 秒随机、与负载正相关）**重建 libusb 上下文就够**（实测 6/6、5/5 全恢复，USB 复位是白付的代价）；**开不起来**（`uvc_start_streaming failed: I/O error` / `UVC format/interface negotiation failed: Invalid mode` / `negotiated_payload` 在 3072↔0 之间跳）**重建上下文救不回来**（实测连试 9 次全败，设备固件侧卡死了），只有 USB 复位/重枚举能洗。改动：新增 3 秒停滞看门狗（`STREAM_STALL_TIMEOUT_SECONDS`，首帧 4 秒）——此前整路静默报废没有任何人管；停摆（`rc>0`）走 `uvc_exit`+`uvc_init` 重建上下文；开不起来（`rc<0`）计入 `hard_failures`，**连续 2 次**升级成 USB 复位（`USB_RESET_LIMIT` 3 次封顶——设备真坏了时不设上限会变成每 2 秒复位一次、把同 Hub 的另外两路一直按在地上），而停摆会**清零**该计数，免得几次停摆凑数误触发复位去打扰邻居；**复位要抢在 `uvc_stop_streaming` 之前**（`teardown_failed_open`）——卡死设备上 `uvc_stop_streaming` 会一直等它那批永远回不来的等时传输，实测能把客户端那 2 秒宽限耗光而被 SIGKILL，进程死在这中间、设备就停在激活的 alt setting 上，下一轮启动照样起不来（用户 09:24 的日志正是断在 startup failed 与 usb reset 之间）；所有阈值由客户端窗口倒推（`SERVICE_START_TIMEOUT_S = 10.0`：每次失败约 0.3 秒 + 1 秒间隔，第 2 次失败在 t≈2 秒触发复位、重枚举加重开约 1 秒、t≈3 秒就能出帧，10 秒够用；旧的「重开 20 秒零帧才复位」在真实启动场景**永远够不到**——20 > 10，且只挂在零帧分支上，实测到的 `I/O error` 根本不走那条）；复位语义实测——打在**健康**设备上是原地端口复位（内核 `reset high-speed USB device number N`，**devnum 不变**），打在**卡死**设备上是掉线再重枚举（`USB disconnect` + `new high-speed USB device`，**devnum 变了**）**这才会好**，而 libusb 在掉线重枚举的窗口里返回 `rc=-4 (No such device)` 是**报错但事办了**、别被它误导；`libusb_reset_device` 用 `dlsym(RTLD_DEFAULT, …)` 取，不新增 NEEDED、不需要 root（设备节点 udev MODE=0666）；顺带修每秒 fps 上报基线（`previous_received` 从 0 起算，重开后把进程启动至今的全部帧数当成本窗口增量，算出 164/207/251 的假速率——纯日志问题，但会把人带偏）。真机验证：确定性升级测试（第 1 次失败不复位、第 2 次 `usb reset: rc=0 (Success)`、打满 3 次后停手）、三路 90 秒回归 0 停摆 0 误复位（2694/2683/2684 帧 ≈29.9fps）、SIGTERM 退出 1.16 秒（旧 1.13 秒）不超客户端 2 秒宽限。**源码位置**：`online/` 在 .gitignore:56 里、不入库；本次把这两个程序的源码连同构建配方搬进了 `core/gripper/camera_service_src/`（`./build.sh` 是唯一构建入口——它替我们处理 libusb 的 pkg-config shim、`-DCMAKE_POLICY_VERSION_MINIMUM=3.5`、以及链接后去掉 RUNPATH 里那个空条目，手工 cmake 会在这些地方卡住；产物装到 `core/gripper/native/camera_service/build/`，旧件按 `.pre_rebuild_<时间戳>` 备份），以后不必再从 libusb 头文件、pkg-config、RUNPATH 那一整串摸起。交付副本 `programs/camera_service/src/camera_service.c` 未动、与 `程序清单.txt` 第 18 行一致。**RGB 断联���根因（2026-09-15 查明，本条是用户「还是会断联」的正面回答）：服务自愈之后相机仍会断，断的原因是 DECXIN 跑在高带宽等时档 alt7 上时每 68~116 秒静默停摆一次，两块控制器（AMD `1022:43fc`/PCI `0000:0a:00.0` 与 `1022:15b7`/`0000:74:00.4`）上都一样。机制**未查明**：停摆当时实际吞吐只有 1.66 MB/s（峰值 2.63），离 alt7 预留的 10.24 MB/s 差得远，「带宽不够」解释不通——**别把机制写死**。alt6 同样三路下长跑不停，而两档出帧率一模一样（都 30.00 fps），alt7 多出来的每帧余量（327680 对 241664 字节）换不到任何看得见的好处。此前两个结论已推翻、别再引用：「bus 1 上 alt7 是好的」——那条所谓干净腿根本没跑在 alt7 上，旧二进制里 ini 的 `forced_*` 是死的、服务只把 ini 的值原样打进日志，读到的 `alt=7 payload=1280` 是它在**复读**，**判断一条腿真实档位只认 `[LIBUVC-QUIRK] ... alt=N payload=M ... xfers=` 那一行**；以及同源的「停摆是控制器特异的」。改动：libuvc 新增运行时接口 `uvc_set_altsetting_override()`（声明在 `include/libuvc/libuvc.h`、实现在 `src/device.c`，`uvc_device_handle_t` 是 calloc 出来的、新字段自动零初始化），`forced_altsetting`/`forced_payload` 从此**真正生效**——此前这两个 ini 字段只用于校验和打印，改 ini 完全不改变行为，极容易误判；起始档位由 app 决定、取**档位表里最保守的一档**（`uvc_camera_service.py` 的 `_starting_mode` 优先级：上一轮学到的 > 最后一档 > 扫描程序报的首选档），**不按机器/控制器写死**（机架插在哪条总线不固定，用户明说不是永久的），曾经那张「敌意控制器」表已删；降档梯子 `maybe_downgrade_altsetting`：当前档位连着停摆 2 次、或连着开不起来 3 次（后者覆盖 STREAMON 阶段就排不下带宽、流根本起不来的情形，停摆那条路永远等不到）就退一档并把结论**落盘**（键 = `vid:pid × 控制器 PCI 路径 × 相机序列号`，一个键一个文件，放 `native/gripper_version1/camera_modes/`——**不能放服务的 runtime 目录，那里每次租约释放整个删掉**），稳定跑满 `CLEAN_RUN_SECONDS=300` 清零停摆计数；**降档必须同时清掉两个计数**——门槛是拿 `==` 比的，只清一个的话另一条路降完一档就永远不再命中，表里剩下的档位形同不存在（DECXIN 只有两档，正好把这个缺陷盖住了）；两条路的日志都在调用**之前**抓计数，否则清零后只能打出「0 停摆」，正好把最该看的那次降档说成没有依据；`tools/discover_uvc_config.c` 如实报**相机描述符里的首选档**（alt7），app 拿它跟服务端档位表对一遍、确认这一对是梯子上的任意一档，对不上就报「扫描程序与服务端档位表已经脱节」（那说明两个程序分开编了，必须一起重编）；`./build.sh --test` 从点名跑 `test-frame-integrity` 改成走 `ctest`——`tests/test_altsetting_ladder.c` 虽然在 `CMakeLists.txt` 里注册了 `add_test`，此前却一次也没被执行过，上面那个「降一档就卡死」正好落在它本该覆盖的范围内。真机验证：ini 强制 alt7 → 78 秒停摆 → 116 秒再停 → 服务打出 `2 stalls at alt=7; dropping to alt=6 payload=944` → 重开在 alt6 → 169 秒 30fps 零停摆，整条降档+恢复路径走通；装 app 自己生成的 ini（alt6 默认）跑 **600 秒三路：0 停摆 / 0 重建 / 0 启动失败 / 0 复位**，17513/17496/17487 帧（30.00/30.00/29.80 fps），日志里 `[LIBUVC-QUIRK] … alt=6 payload=944 endpoint=944 xfers=32 (altsetting override)` 证明确实跑在 alt6 上、ini 真的生效了；装机后再做一次 300 秒回归同样全零停摆；装机产物与源码构建逐个 md5 相同、RUNPATH 仍只有 `$ORIGIN/third_party/libuvc`。离线侧新增 `tools/tests/test_camera_altsetting_mode.py`（19 条，覆盖最保守档/学到值优先/表外值忽略/扫描程序与服务端脱节必须先报错，并钉死与 C 测试共用的落盘键串），`test_altsetting_ladder.c` 补上「两个计数都要清零」的断言并**反向验证过不是空跑的**（把清零那行注释掉，该测试当场断言中止）。装机后需重启主程序才能同时拿到新的 `uvc_camera_service.py` 与新服务，否则两边档位要求对不上会像 2026-09-15 09:24 那样整个起不来。扫描侧：移植交付包「设备扫描逻辑与程序_20260914」，夹爪与 UVC/ESP32 的配对从 **USB 根端口/控制器**改走 **NVS 序列号**——旧规则（`_bus_root`/`_root_port`，外加「同一 USB2 总线出现双 rig 就拒扫」）的前提就是错的：Fays 是 USB3/FT602 挂在配套的 5000M 总线上，跟 UVC/ESP32 本来就不共根，只能靠猜。新链路：UVC 组 → 唯一 ESP32（`bus-outer.` 开头）→ 串口发 `QF` 读它 NVS 里绑定的 Fays 序列号 → 与官方 SDK 枚举出的 `device.serial` 比对（`_resolve_fays_group` 三步，任一步不唯一就明确拒绝；`_match_esp` 拒收空序列号，不再按端口或枚举顺序猜）。SDK 探测前先 `validate_fays_superspeed` 预检，再以 `serial_only_fast=True` 快速枚举序列号（`fays_serial_probe.py` 加 `--serial-only-fast`；超时不再只报一句 timeout，解码 stdout/stderr 并附最后 20 行），`_probe_serial` 交叉核对 SDK serial 与 NVS 绑定；双 rig 新增「在用时跳过」——`fays_device_guard(port, timeout=0.0)` 探到另一 rig 正持有该设备就跳过而不是占用。串口侧：`CONNECT_BOOT_DELAY = 2.0` 死等改成 `CONNECT_BOOT_TIMEOUT = 2.0` 轮询 `?` 握手（实际尝试次数按真实值上报，不再报上限），打开加 `exclusive=True`，新增 `query_fays_serial()`/`set_fays_serial()`（`QF` 查询 / `WF:<serial>` 写入，值校验 `[A-Za-z0-9._-]{1,64}`）；顺带修 `GripperSerial.send()` 只拿首字符去查命令表（`[:1]`）——`"QF"` 因此永远匹配不上自己的期望表，改成先查全命令再退回首字符。UVC 发现程序侧：`_native_env(binary)` 改成优先用二进制自带的 `third_party/libuvc`（不再指望环境里恰好有），`_run_discovery` 加互斥的 `--topology-only`/`--identity-only`/`--skip-flash` 三种扫描深度。**前置条件：ESP32 固件必须认识 `QF`/`WF:`，当前 `online/esp32_proc` 的固件还不认识，会失败关闭并报「查询 Fays 序列号失败: ERR」，需先烧固件。** 新增离线自检 `tools/tests/test_gripper_fays_pairing.py`（假串口 + 假桥接 + 假探针，覆盖 QF/WF 往返、ESP 匹配、按序列号解析、整套 acquire、UVC 关联，并核对部署的原生程序确实内嵌了新参数）。s80c 上色工具修隔帧重复（`tools/s80c_arm_convert/convert_arm_dataset.py`，v1.3.4 之后单独提交的补丁）：`pooled_episodes_v1` 这版录制**每帧写两行**（`frame_index` = 0,0,1,1,…，同一帧两行的 `timestamp`/`hardware_ns` 逐值相同）而视频只有一帧，工具把行数当帧数（`n = tbl.num_rows`）、主流程再按视频帧号 1:1 取 `hw_ns[i]`，于是每个时间戳被连送两遍——离线 ISP 对重复时间戳复用上一帧的输出，输出视频就隔帧重复。实测 rec001 无损版 833 帧里 394 帧与前一帧逐字节相同、且 394 个全落在奇数位（每对时间戳的第二个），源视频 0 重复；同一根因还让 IMU 侧车**少一半**（修复前 `hw_ns[:n_frames]` 只够到第 417 个时间戳，其后的 IMU 样本全被「晚于末帧 hw」规则丢掉，输出只剩 416 行 / 13.8 秒，修复后 832 行 / 27.7 秒，与视频时长 27.8 秒对上）。现按 `frame_index` 折叠冗余行，但**只在同一 `frame_index` 名下所有行的 `timestamp` 与 `hardware_ns` 逐值相同时才折**，否则打告警原样不动——全库 142 个带 `frame_index` 的 parquet 里 129 个本就每帧一行（空操作）、1 个真冗余（rec001，1666 行 → 833 帧）、12 个行间时间戳互不相同（折叠会丢时间戳，一律只告警）。上色链路一行未动，同一份 config、同一个离线 ISP、`--sdk-wb-auto` 照旧，灰世界增益与修复前逐位相同。承接 v1.3.4 的新夹爪接入即自动生成运行标定并连接（Fays S80M）：此前接入一只新夹爪要人工两步——先在夹爪上位机点 `device_setup`、再在采集机跑 `tools/import_gripper_calibration.py` 导入，漏掉任一步主程序直接拒绝启动（「当前 Fays 缺少运行标定文件…请先在夹爪上位机中运行 device_setup」）；现在 `SingleFaysLease.acquire()` 发现 per-serial YAML 缺失时，就在设备锁内调厂商导出程序从**这只夹爪自身**读出厂标定、生成 SDK YAML 与 ORB YAML（鱼眼 `stereoRectify` 求 P1/R1 + IMU 外参 `T_b_c1` + 探针读五项噪声/频率），复核落盘路径后直接连上，已有标定走 `isfile` 快路径（启动零额外开销、不碰设备）——这两个文件是**逐设备**出厂标定不可跨设备复用（实测 098/099 三组全不同），只能现场读；设备面板夹爪条目右键加「重新读取出厂标定」（录制中禁用，标定前自动关该夹爪、完成后开回），`tools/import_gripper_calibration.py` 加 `--generate`（旧文件先备份 `.bak_<时间戳>`）供命令行强制重生成；顺带修掉生成产物第 3 行的出处注释——厂商模板写死指向 `3500000261870088`，照抄会让每只新夹爪的 IMU 外参都被记成「取自另一台设备」，现改写成本机序列号（历史产物不动）。承接 v1.3.3 的力矩阵/触觉力与 RGB 视频的时间戳对齐：**力侧此前完全没有时间戳**——同一行里的 RGB 帧和力样本不是同时刻采集的，RGB 走外部帧源队列取队头最旧帧、力/矩阵走 latest-wins 单槽取当下最新，于是「行号相同」≠「时刻相同」，力恒领先 RGB 且领先量随录制时长增长（RGB 源 30.84fps vs 写线程 30fps，实测约 1 帧/秒，下游观测到的滞后 3 帧就是这么来的），力矩阵走独立泵线程还与 3 向量力各记各的时刻。修法是让每行自描述：`tactile_ready` 加第 5 个载荷 `capture_ns`（在 SDK 回调入口取），`pipeline.write_tactile_force/_force_matrix` 落成独立的 `observation.gripper_{side}_force_ns` / `_force_matrix_ns` 稀疏 int64 列（与 `hardware_ns` 同宿主单调钟时基，features 里声明 `encoding: host_monotonic_ns`），下游按时间取最近邻即可还原真实配对，精度上界=半个力样本间隔；顺带修 `rgb_frame_ready`/`stereo_frame_ready` 的 `pyqtSignal(int)` 把 `time.monotonic_ns()` 按 C++ qint32 静默截断成负数（每 2.147s 翻符号），改 `object` 封送——这也解释了此前用 `hardware_ns` 解回卷时凭空造出上百帧假漂移、把"中位 5.8 帧 / 最大 ±80 帧"报成对齐误差（真值是 ~3 帧，正确规则是**无符号**：单调钟 + FIFO 消费 ⇒ 真步长恒非负）；新增 `scripts/align_modalities.py` 处理端最近邻对齐工具，对 v1.3.3 之前录的 episode 明确报「无法对齐（只能重录）」而不用增长率去猜。承接 v1.3.2 的 SLAM 陈旧帧入库前拦截与轨迹显示深拷贝修复。：桥接按「连续回退次数」判定——单帧脏读丢弃、连丢 30 帧才判定时钟真跳变并换基准放行（此前每一帧回退都会让核心库清空 IMU 队并重建地图、位姿停发 0.2–1.34 s，静止时更久），新增 `[TIME_DROP]`/`[TIME_REBASE]` 现场行并**无条件**打进 GUI 日志（此前落进未匹配行被 50 条上限吃掉——实测原生日志 4 次回退、GUI 日志 0 条，真出事时反而看不见），且带 `seq`/`prev_seq` 对比结论以区分「SDK 乱序投递 / 重复投递同一帧 / 帧配了旧时间戳」三种成因（时间戳上三者长得一模一样，对策完全不同）；逐秒遥测 `[FPS_DATA]` 改「只在异常时出声」（健康静默、进入异常与恢复各一行、持续异常每 30 s 重复，全量逐秒流仍在原生日志里），并修 `wait_sdk_ready` 就绪门被**粘滞** `state.error` 锁死——任何信息性输出（如 ld.so 的 `cannot be preloaded ... ignored.`）都会让标定明明已完成的这一次返回 False、报出误导的「未等到 [FAYS-CALIB] 标记」（2026-09-10 18:32 假超时事故，文案白名单 + 去掉粘滞判断双管修）；原生日志在 runtime 目录 `rmtree` 之前留档到 `logs/slam_native/`（保留最近 20 份），修「一次干净退出的会话其原生日志不可恢复」——排查 SLAM 崩溃时唯一的证据曾随目录一起被删；轨迹显示去掉 Qt 主线程上的整条深拷贝（正是这次拷贝让 `_rendered_trajectory is traj` 判等恒为假、每个位姿都在主线程复制随会话线性增长的点列，即「画一段时间后帧率变低」的直接原因），显示上限 400→6000，并以向量化投影 + 一次 `drawPolyline` 绘制，修「十几秒后轨迹显出折角」（降采样按 stride 翻倍使顶点数恒落 [上限/2, 上限]，上限 400 时每段跨 67 ms 且随 stride 每翻一倍继续变粗，观感像 SLAM 出点变慢而数据一直满 30 Hz，是绘制侧丢的）；RGB 外部队列在录制开始/结束/中止三个边界排空，修「上一段残留 + 本段启动窗口累积被写成新视频开头」（实测每段开头约 28 帧与上一段 episode 末帧逐帧匹配，队列满时还占 ~110 MB/槽）；任务进度只上报后端当前任务列表里存在的任务（本地自建任务平台没这个项目，上报必被拒 400），且后端该项目口径为 `"sessions"`（从没收到过任何上报）时首次送本机**全量**当基线——只送增量会把后端计数从 session 数砸成增量本身（现场：3/3/3 的项目再录一条变 1）。承接 v1.3.1 的力矩阵 5 档落盘与 SLAM 停落 slam_pose 列。

collector/core/gripper/camera_service_src/CMakeLists.txt

@@ -0,0 +1,100 @@
+cmake_minimum_required(VERSION 3.16)
+project(ksq_camera_service C)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+set(BUILD_EXAMPLE OFF CACHE BOOL "" FORCE)
+set(BUILD_TEST OFF CACHE BOOL "" FORCE)
+set(CMAKE_BUILD_TYPE Release CACHE STRING "" FORCE)
+
+add_subdirectory(third_party/libuvc)
+
+find_package(Threads REQUIRED)
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(LIBUSB REQUIRED IMPORTED_TARGET libusb-1.0)
+
+add_executable(ksq-camera-service
+    src/camera_service.c
+)
+target_include_directories(ksq-camera-service PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/third_party/libuvc/include
+)
+target_compile_definitions(ksq-camera-service PRIVATE
+    _GNU_SOURCE
+)
+target_compile_options(ksq-camera-service PRIVATE
+    -Wall -Wextra -Wpedantic
+)
+target_link_libraries(ksq-camera-service PRIVATE
+    LibUVC::UVC
+    PkgConfig::LIBUSB
+    Threads::Threads
+)
+
+add_executable(sonix-flash-probe
+    tools/sonix_flash_probe.c
+)
+target_compile_options(sonix-flash-probe PRIVATE
+    -Wall -Wextra -Wpedantic
+)
+target_link_libraries(sonix-flash-probe PRIVATE
+    PkgConfig::LIBUSB
+)
+
+add_executable(discover-uvc-config
+    tools/discover_uvc_config.c
+)
+target_include_directories(discover-uvc-config PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/third_party/libuvc/include
+)
+target_compile_definitions(discover-uvc-config PRIVATE
+    _GNU_SOURCE
+)
+target_compile_options(discover-uvc-config PRIVATE
+    -Wall -Wextra -Wpedantic
+)
+target_link_libraries(discover-uvc-config PRIVATE
+    LibUVC::UVC
+    PkgConfig::LIBUSB
+)
+
+install(TARGETS ksq-camera-service RUNTIME DESTINATION bin)
+
+# Hardware-free integrity regression tests for the production callback.
+enable_testing()
+add_executable(test-frame-integrity tests/test_frame_integrity.c)
+target_compile_definitions(test-frame-integrity PRIVATE _GNU_SOURCE)
+target_compile_options(test-frame-integrity PRIVATE -Wall -Wextra -Wpedantic)
+target_link_libraries(test-frame-integrity PRIVATE
+    LibUVC::UVC PkgConfig::LIBUSB Threads::Threads)
+add_test(NAME frame-integrity COMMAND test-frame-integrity)
+
+# The altsetting ladder decides which isochronous setting each camera is opened
+# with, and its state-file key has to be derived identically in Python. Neither
+# is observable without hardware, so pin both here.
+add_executable(test-altsetting-ladder tests/test_altsetting_ladder.c)
+target_compile_definitions(test-altsetting-ladder PRIVATE _GNU_SOURCE)
+target_compile_options(test-altsetting-ladder PRIVATE -Wall -Wextra -Wpedantic)
+target_link_libraries(test-altsetting-ladder PRIVATE
+    LibUVC::UVC PkgConfig::LIBUSB Threads::Threads)
+add_test(NAME altsetting-ladder COMMAND test-altsetting-ladder)
+
+# Checkout deployment keeps the bundled libuvc next to these executables.
+# Avoid CMake embedding the build machine's absolute checkout directory.
+#
+# CMake appends an empty element to this list for ksq-camera-service (it counts
+# Threads::Threads as an empty link directory), which would leave the RUNPATH as
+# "$ORIGIN/third_party/libuvc:" -- and an empty element means "also search the
+# current working directory". build.sh strips that element after the link and
+# fails the build if it survives; do not "fix" it here by hand, the per-target
+# SKIP_BUILD_RPATH and global CMAKE_SKIP_RPATH routes both make it worse
+# (CMake then emits the entire empty list).
+foreach(_target ksq-camera-service discover-uvc-config test-frame-integrity
+        test-altsetting-ladder)
+    set_target_properties(${_target} PROPERTIES
+        BUILD_RPATH "$ORIGIN/third_party/libuvc"
+        INSTALL_RPATH "$ORIGIN/../lib"
+        BUILD_RPATH_USE_ORIGIN TRUE)
+endforeach()

collector/core/gripper/camera_service_src/README.md

@@ -0,0 +1,181 @@
+# 相机服务与 UVC 扫描程序（源码入库版）
+
+`ksq-camera-service`（libuvc 推流服务，走 IPC 给主程序供帧）与
+`discover-uvc-config`（UVC 相机扫描：拓扑枚举 + Flash 身份读取 + 生成配置）的
+**源码**。用 `./build.sh` 构建，产物安装到
+`core/gripper/native/camera_service/build/`。
+
+## 为什么源码在这里
+
+这两个程序的源码原先**只存在于 `online/`**（`.gitignore:56` 整个目录不上传），
+`core/gripper/native/` 下只有编译好的二进制，重建配方只活在当时那次排查的会话里
+—— 二进制一旦丢失或要改一行，就得从头摸清 libusb 头文件、pkg-config、RUNPATH
+这一整串。2026-09-15 把源码连同构建配方搬进 core，让采集程序自己的相机逻辑随包入库。
+
+## 目录
+
+```
+CMakeLists.txt            与交付包 online/camera_service/CMakeLists.txt **逐字节一致**
+src/camera_service.c      推流服务
+tools/discover_uvc_config.c   UVC 扫描程序（三档扫描深度）
+tools/sonix_flash_probe.c     Sonix Flash 读写工具（CMakeLists 里的目标之一）
+tests/test_frame_integrity.c  无硬件回归测试（MJPEG 回调完整性）
+third_party/libuvc/       vendored libuvc 0.0.7，含本地补丁 ksq_altsetting_quirks
+                          （src/stream.c：DECXIN 3060→1280、Sightac 3072→800）
+build.sh                  构建脚本（唯一入口）
+```
+
+## 构建
+
+```sh
+core/gripper/camera_service_src/build.sh            # 构建 + 安装（旧的先备份）
+core/gripper/camera_service_src/build.sh --test     # 顺带跑 test-frame-integrity
+core/gripper/camera_service_src/build.sh --no-install
+```
+
+依赖：`gcc`、`cmake >= 3.16`、`make`、libusb-1.0 头文件（`libusb-1.0-0-dev`，或退到
+conda 的 `include/libusb-1.0`）。libjpeg 头文件可选，但**缺了 libuvc 会退化成不支持
+MJPEG 解码**，构建脚本会告警 —— 线上产物是带 libjpeg 的，两者不一致。
+
+安装会按 `.pre_rebuild_<时间戳>` 备份旧二进制，回退就是覆盖回去。
+
+## 三个已踩过的坑（改脚本前先看）
+
+1. **`*** 目标模式不含有"%"`**：真正的病因是 vendored `FindLibUSB.cmake` 走
+   `find_library()` 找不到库（系统只有 `libusb-1.0.so.0`，没有给链接器用的
+   `libusb-1.0.so`），把 `LibUSB::LibUSB-NOTFOUND` 写进了依赖表；GNU make 把那条
+   依赖里的第二个冒号当成静态模式规则的分隔符，于是报出这个与病因毫不相干的错。
+   解法是 `-DLibUSB_LIBRARY=...` 预置缓存，让 `find_library` 整个跳过。
+2. **pkg-config 里只能有一个 `-I`**：`FindLibUSB.cmake` 把 `${LibUSB_INCLUDE_DIRS}`
+   不 quote 地交给 `set_target_properties`，两个 `-I` 就变成三个实参报错。而
+   libuvc 内部用 `<libusb.h>`、两个工具用 `<libusb-1.0/libusb.h>`，两种写法都要能
+   解析 —— 所以 shim 目录里同时放 `libusb-1.0/` 与 `libusb.h` 两个软链，只给一个 `-I`。
+3. **`ksq-camera-service` 的 RUNPATH 会多一个空条目**（`$ORIGIN/third_party/libuvc:`）：
+   CMake 把它链的 `Threads::Threads` 在本机算成了空目录。RUNPATH 里的空条目等于让
+   加载器去**当前工作目录**找 `libuvc.so.0`，线上那份手工链的没有这个口子，所以
+   构建脚本会在链接后把这个冒号就地改成字符串终止符（等价 `chrpath -d` 的收缩改写；
+   本机没有 chrpath/patchelf）。校验段会断言空条目已消失。
+
+## 等时档位（altsetting）：ini 说了算，服务会自己降档
+
+**`forced_altsetting` / `forced_payload` 是真正生效的**，不是校验用的装饰。服务
+打开设备后立刻把这两个值交给 libuvc 的新 API `uvc_set_altsetting_override()`
+（声明在 `include/libuvc/libuvc.h`，实现在 `src/device.c`，`uvc_device_handle_t`
+是 `calloc` 出来的，新字段自动零初始化，没设过就退回编译期那张
+`ksq_altsetting_quirks` 表）。**改档位只需要改 ini。**
+
+在此之前这两个 ini 字段只用于校验和打印，真正决定档位的是编译进 libuvc 的表
+——所以「改 ini」完全不改变行为，这一点极容易误判。**判断一条腿实际跑在哪个档
+位，只认日志里的 `[LIBUVC-QUIRK] ... alt=N payload=M ... xfers=` 那一行**（带
+`(altsetting override)` 后缀表示走的覆盖值）；服务自己那行
+`vidpid=... alt=7 payload=1280` 只是 ini 的回声，在旧二进制上与真实档位无关。
+
+档位表在 `src/camera_service.c`（`kDecxinModes` / `kSightacModes`），**必须按
+从好到差降序**，降档梯子按表往下走一格、走到最后一项就不再降。两个门槛分开计：
+连着停摆 `STALLS_BEFORE_ALTSETTING_DOWNGRADE`(2) 次降档；连着开不起来
+`OPEN_FAILURES_BEFORE_ALTSETTING_DOWNGRADE`(3) 次也降档（覆盖「STREAMON 阶段
+就排不下带宽、流根本起不来」那种，停摆那条路永远等不到）。结论按
+「相机序列号 × 控制器 PCI 路径���落盘到 `state_dir`，下次开机直接读。
+
+**降档必须把两个计数都清零**（2026-09-15 修）。门槛是拿 `==` 比的，计数停在
+门槛上就再也不会命中——原来 `maybe_downgrade_altsetting` 只清了 `stalls_at_mode`，
+于是「开不起来」那条路**降完一档就永久卡死**，表里剩下的档位形同不存在
+（DECXIN 只有两档，正好被掩盖住；三档机型上就会露出来）。两条路的日志都在
+调用**之前**抓计数，否则清零后只能打出「0 failed opens」，把最该看的那次降档
+说成没有依据。
+
+**这套东西能测，而且以前从来没被测过**（2026-09-15 修）。`tests/test_altsetting_ladder.c`
+一直在 `CMakeLists.txt` 里注册着 `add_test`，但 `build.sh --test` 是点名跑
+`test-frame-integrity` 的，梯子那个**一次也没执行过**——上面那个「降一档就卡死」
+的 bug 正好落在它本该覆盖的范围内。现在 `--test` 走 `ctest`，新增测试只要
+`add_test` 就自动纳进来。反向验证过：把清零那行注释掉，`altsetting-ladder`
+立刻断言中止，不是个空跑的测试。
+
+**起始档位由 app 决定，不在这张表里**：`uvc_camera_service.py` 的
+`_starting_mode` 取**表里最保守的一档**（＝最后一项）。实测 DECXIN 的 alt7
+（10.24 MB/s）在整机三路一起出流时每 45~130 秒必停摆一次，alt6（7.552 MB/s）
+同样三路下长跑不停，而**两档出帧率一模一样（都 30.00fps）**——alt7 多出来的每帧
+余量（327680 对 241664 B）换不到任何看得见的好处，所以默认不用它。想要那点余量
+就把 ini 改回 alt7，服务停两次会自己退回 alt6 并把结论落盘。
+
+`tools/discover_uvc_config.c` 报的是**相机描述符里的首选档**（alt7），是如实汇报
+硬件，不是起始档；app 拿它跟服务端档位表对一遍，对不上就报「扫描程序与服务端
+档位表已经脱节」——那说明两个程序分开编了，必须一起重编。
+
+## SIGTERM 收尾：join 必须有界（2026-09-15 修）
+
+**症状**：服务收到 SIGTERM 后退不出来。实测线上二进制卡了 3 分钟以上，只攥着
+DECXIN 的 `/dev/bus/usb/007/032` 一个设备 fd（left/right 都已干净释放），日志
+停在断流那一刻——连 `[SUPERVISION] parent exited` 都没打出来。
+
+**病根**：相机线程陷在 `uvc_open` 的同步 libusb 调用里（卡死的设备上它不返回），
+永远走不到循环头那个 `g_stop` 判断；而 `main` 堵在 `pthread_join` 上等它。
+`g_stop` 置了也没用——没人去看。
+
+**后果**：客户端只等 2 秒（`uvc_camera_service.py` 的 `terminate()` → 等 2 秒 →
+`kill()`），超了就是 SIGKILL，进程死在 libusb 调用中间、设备停在激活的 alt
+setting 上，下一轮照样起不来——正是 2026-09-15 09:24 那次事故的形状。
+`teardown_failed_open` 里「复位抢在 `uvc_stop_streaming` 之前」只覆盖**失败路径**，
+覆盖不到「线程已经卡在 `uvc_open` 里」这一种。
+
+**改法**：`pthread_join` → `pthread_timedjoin_np`。整体预算 1.5 秒、单路 0.8 秒，
+超时就 `pthread_detach` 掉继续走，`main` 一返回进程即结束（内核替我们释放句柄），
+并打一行 `收尾超时：线程未在预算内退出（多半卡在设备调用里），不再等它`。
+跳过超时那一路的统计与 `pthread_mutex_destroy`——线程可能还在用，销毁是 UAF。
+
+**一个坑（第一版就踩了）**：这个 join 循环**同时就是服务的主运行循环**——它在
+**启动时**进入、一直跑到 `g_stop`，不是「收尾时才走的一段」。所以截止时间不能在
+进循环前算好：第一版把 `shutdown_deadline` 放在 `for` 之前，结果服务启动 1.5 秒后
+三路一起「收尾超时」、自己退出了（现象：三路 `总帧=0`、日志里三行收尾超时、
+`SIGTERM → pid` 那行根本没机会打）。现在改成**等 `g_stop` 真置位时才开始计时**，
+没置位时只用 200ms 短超时轮询（成本可忽略）。
+
+**验证**：正常路径真机 45 秒三路 —— left/right 各 1351 帧满帧、decxin 1111 帧，
+SIGTERM 退出 **0.71 秒**（改前 0.56 秒，仍在 2 秒宽限内），服务全程不自杀。
+**超时那条分支本身没能在真机上触发**（没法按需把设备弄卡），只做了代码审查。
+
+## 与交付包的关系
+
+`CMakeLists.txt` 与四个 C 源文件都从交付包 `online/camera_service/` 原样搬来
+（逐字节一致），本仓库只新增 `build.sh` 与这份 README。**改这里的 C 源码时要同步
+回交付包**，否则两边会分叉。
+
+构建产物与线上二进制的实测关系（2026-09-15）：
+
+| 产物 | 与线上二进制 |
+|---|---|
+| `discover-uvc-config` | **逐字节一致**（sha256 `b9d8bba870f60c11…`）——配方忠实 |
+| `ksq-camera-service` | **源码已领先线上**（多了下面的 SIGTERM 收尾修复），且编译选项不同：CMake Release �� `-O3 -DNDEBUG`，线上那份是手工 `-O2`（源码无 `assert()`，`NDEBUG` 无语义影响） |
+| `sonix-flash-probe` | 同上，代码同源、编译选项不同 |
+| `libuvc.so.0.0.7` | 代码同源、编译选项不同；`ksq_altsetting_quirks` 补丁与 `[LIBUVC-QUIRK]` 日志**都在**，NEEDED 三者一致（libusb-1.0.so.0 / libjpeg.so.8 / libc.so.6） |
+
+也就是说 `build.sh` 现在是**单一机制**（一套 CMake 配置编全部目标），代价是
+`ksq-camera-service` 与当年手工链的那个二进制不是同一个字节。重新构建后应重新做
+一次三路相机回归，而不是假定等价。
+
+**2026-09-15 19:29 已按此装机**（`STAMP=20260915_192940`）：`ksq-camera-service`
+现在带自适应档位 + 两个计数都清零的修复。装机前三路回归已做（app 生成的 ini、
+alt6 默认，**600 秒三路零停摆零重建，decxin/left 30.00fps、right 29.80fps**，
+17513/17496/17487 帧），装机后又做了一次 300 秒回归。
+
+**2026-09-15 11:34 曾按此装机**（`STAMP=20260915_113444`）：
+`core/gripper/native/camera_service/build/` 里的 `ksq-camera-service` 当时是
+`07f1f5a34b569b7b`（带 SIGTERM 收尾修复），旧件 `b64b74d810abe482` 备份在同目录
+`.pre_rebuild_20260915_113444`；`discover-uvc-config` 装前装后同为
+`b9d8bba870f60c11`，装不装等价。装机前三路回归已做（90 秒 ×2 腿 + 45 秒修复腿）。
+**另注意 `build.sh` 的安装段不备份 `third_party/libuvc/`**（`rm -f` 直接覆盖、
+`include/` 还是 `rm -rf`），所以这次装机前手工备份了库文件为
+`libuvc.so.0.0.7.pre_rebuild_20260915_113330` + `include.pre_rebuild_20260915_113330/`。
+改脚本时补上这段备份更稳妥。
+
+### glibc 下限：`ksq-camera-service` 2.34 → 2.38（不是新约束）
+
+新编的 `ksq-camera-service` 引用 `__isoc23_strtol@GLIBC_2.38`（GCC 15 默认 C23，
+`strtol` 解析成 C23 语义的符号），最低 glibc 从线上的 2.34 抬到 2.38。看着像门槛
+变高，其实**没有新增约束**：那个**逐字节一致**的 `discover-uvc-config` 本来就要求
+GLIBC_2.38，而它是扫描时每次都要在采集机上跑的 —— 能跑扫描程序就一定能跑这个
+服务。其余产物（`sonix-flash-probe`、libuvc）两边都是 2.34。
+
+不要去给 CMake 钉 `-DCMAKE_C_STANDARD=17` 来消掉它：那会连带把
+`discover-uvc-config` 的 `strtol` 换回旧符号，而它正是目前唯一能逐字节复现线上
+二进制的产物，是「配方忠实」的活证据。

collector/core/gripper/camera_service_src/build.sh

@@ -0,0 +1,244 @@
+#!/usr/bin/env bash
+# 构建 libuvc 相机服务（ksq-camera-service）与 UVC 扫描程序（discover-uvc-config），
+# 产物安装到 core/gripper/native/camera_service/build/。
+#
+# 为什么有这份脚本：这两个程序的源码原先只在 online/（.gitignore 里），core/ 下
+# 只有编译好的二进制，重建配方只活在当时那次会话里 —— 一旦二进制丢了或要改一行
+# 就得从头摸。现在源码随包入库（core/gripper/camera_service_src/），配方固化于此。
+#
+# 依赖：gcc、cmake(>=3.16)、make、libusb-1.0 头文件；libjpeg 头文件可选（缺了
+#       libuvc 会退化：不支持 MJPEG 解码，实测产物 NEEDED 里就没有 libjpeg.so.8）。
+#
+# 用法：
+#   ./build.sh                 构建 + 安装（旧的同名二进制先备份为 .pre_rebuild_<时间戳>）
+#   ./build.sh --no-install    只构建，不动 core/gripper/native/
+#   ./build.sh --test          构建后跑 ctest（全部无硬件回归测试）
+#   ./build.sh --jobs 4        限制并行度
+set -euo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO="$(cd "$HERE/../../.." && pwd)"
+OUT="$REPO/core/gripper/native/camera_service/build"
+BUILD="$HERE/build"
+SHIM="$BUILD/shim"
+
+DO_INSTALL=1
+DO_TEST=0
+JOBS="$(nproc 2>/dev/null || echo 4)"
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --no-install) DO_INSTALL=0 ;;
+        --test)       DO_TEST=1 ;;
+        --jobs)       JOBS="${2:?--jobs 需要一个数字}"; shift ;;
+        -h|--help)    sed -n '2,18p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; exit 0 ;;
+        *) echo "未知参数: $1（-h 看用法）" >&2; exit 2 ;;
+    esac
+    shift
+done
+
+die() { echo "错误: $*" >&2; exit 1; }
+
+# ---------------------------------------------------------------- 依赖定位
+
+# libusb 头文件：系统装了 libusb-1.0-0-dev 最省事；否则退到 conda 的 include。
+# 注意头文件父目录要进 -I，因为源码里既有 <libusb-1.0/libusb.h>（sonix_flash_probe）
+# 也有 <libusb.h>（libuvc 自己），两种写法都得能解析。
+find_libusb_include() {
+    local candidate
+    for candidate in \
+        "${LIBUSB_INCLUDE_PARENT:-}" \
+        /usr/include \
+        /usr/local/include \
+        "${CONDA_PREFIX:-}/include" \
+        "$HOME/miniconda3/include" \
+        "$HOME/anaconda3/include"
+    do
+        [ -n "$candidate" ] && [ -f "$candidate/libusb-1.0/libusb.h" ] && {
+            echo "$candidate"; return 0; }
+    done
+    return 1
+}
+
+# libusb 运行库：优先系统 multiarch 的 .so.0（只链 soname，产物不带任何本机
+# RUNPATH 依赖），再退到 conda。
+find_libusb_library() {
+    local candidate
+    for candidate in \
+        "${LIBUSB_LIBRARY:-}" \
+        /usr/lib/x86_64-linux-gnu/libusb-1.0.so.0 \
+        /usr/lib/libusb-1.0.so.0 \
+        /usr/local/lib/libusb-1.0.so.0 \
+        "${CONDA_PREFIX:-}/lib/libusb-1.0.so" \
+        "$HOME/miniconda3/lib/libusb-1.0.so" \
+        "$HOME/anaconda3/lib/libusb-1.0.so"
+    do
+        [ -n "$candidate" ] && [ -e "$candidate" ] && { echo "$candidate"; return 0; }
+    done
+    return 1
+}
+
+LIBUSB_INC_PARENT="$(find_libusb_include)" \
+    || die "找不到 libusb-1.0 头文件。装 libusb-1.0-0-dev，或用 LIBUSB_INCLUDE_PARENT=<含 libusb-1.0/ 的目录> 指定。"
+LIBUSB_LIB="$(find_libusb_library)" \
+    || die "找不到 libusb-1.0 运行库。装 libusb-1.0-0，或用 LIBUSB_LIBRARY=<路径> 指定。"
+
+# libjpeg：FindJpegPkg 会先走 CMake 自带的 FindJPEG，这里预置缓存值把它钉死在
+# 系统头/库上，免得 cmake 是 conda 装的时候误抓 conda 的 libjpeg。
+JPEG_ARGS=()
+if [ -f /usr/include/jpeglib.h ]; then
+    JPEG_ARGS+=("-DJPEG_INCLUDE_DIR=/usr/include")
+    for lib in /usr/lib/x86_64-linux-gnu/libjpeg.so /usr/lib/libjpeg.so; do
+        [ -e "$lib" ] && { JPEG_ARGS+=("-DJPEG_LIBRARY=$lib"); break; }
+    done
+else
+    echo "警告: 没有 /usr/include/jpeglib.h，libuvc 将编译成不支持 MJPEG 解码" >&2
+fi
+
+# ---------------------------------------------------------------- 头文件 shim
+#
+# 顶层的 CMakeLists 用 pkg_check_modules(LIBUSB REQUIRED ... libusb-1.0)，而系统
+# 上根本没有 libusb-1.0.pc（那个文件由 -dev 包提供）。这里现造一个，指向真实头
+# 文件和运行库的 soname（-l:libusb-1.0.so.0 不带 -L，所以不会给产物塞 RUNPATH）。
+#
+# 只有**一个** -I，而且是 shim 目录而不是真实头目录：vendored 的
+# FindLibUSB.cmake 把 ${LibUSB_INCLUDE_DIRS} 不 quote 地交给
+# set_target_properties，一旦 pkg-config 给出两个 -I，它就会变成三个实参报
+# 「set_target_properties called with incorrect number of arguments」。
+# 而两种 include 写法都得满足 —— libuvc 内部是 <libusb.h>，两个工具是
+# <libusb-1.0/libusb.h> —— 所以 shim 目录里同时放 libusb-1.0/ 和 libusb.h 两个软链。
+
+mkdir -p "$SHIM/include" "$SHIM/pkgconfig"
+ln -sfn "$LIBUSB_INC_PARENT/libusb-1.0" "$SHIM/include/libusb-1.0"
+ln -sfn "$LIBUSB_INC_PARENT/libusb-1.0/libusb.h" "$SHIM/include/libusb.h"
+
+cat > "$SHIM/pkgconfig/libusb-1.0.pc" <<EOF
+prefix=$SHIM
+exec_prefix=\${prefix}
+libdir=$(dirname "$LIBUSB_LIB")
+includedir=$SHIM/include
+
+Name: libusb-1.0
+Description: C API for USB device access from Linux, Mac OS X, Windows, OpenBSD/NetBSD and Solaris userspace
+Version: 1.0.27
+Libs: -l:$(basename "$LIBUSB_LIB")
+Cflags: -I\${includedir}
+EOF
+
+# ---------------------------------------------------------------- 配置 + 构建
+#
+# -DCMAKE_POLICY_VERSION_MINIMUM=3.5：libuvc 的 cmake_minimum_required 是 3.1，
+#   CMake 4.x 直接拒绝，给个下限放行。
+# -DLibUSB_LIBRARY=...：vendored 的 FindLibUSB.cmake 走 find_library(NAMES
+#   ${LibUSB_LIBRARIES})，而系统的 libusb 只有 .so.0、没有给链接器用的 .so 软链，
+#   find_library 会失败并把 "LibUSB::LibUSB-NOTFOUND" 写进依赖表 —— GNU make 会
+#   把那条依赖里的第二个冒号当成静态模式规则分隔符，报出与病因毫不相干的
+#   「*** 目标模式不含有"%"」。预置这个缓存变量让 find_library 整个跳过。
+
+echo "libusb 头文件 : $LIBUSB_INC_PARENT"
+echo "libusb 运行库 : $LIBUSB_LIB"
+echo "构建目录      : $BUILD"
+
+PKG_CONFIG_PATH="$SHIM/pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}" \
+cmake -S "$HERE" -B "$BUILD" \
+    -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
+    -DBUILD_EXAMPLE=OFF \
+    -DBUILD_TEST=OFF \
+    -DLibUSB_LIBRARY="$LIBUSB_LIB" \
+    "${JPEG_ARGS[@]}"
+
+cmake --build "$BUILD" -j"$JOBS"
+
+# ksq-camera-service 的 RUNPATH 末尾会多出一个空条目（"$ORIGIN/third_party/libuvc:"）——
+# CMake 把它链的 Threads::Threads 在本机算成了空目录，空条目进了 rpath 列表。RUNPATH
+# 里的空条目等于让加载器去**当前工作目录**找 libuvc.so.0，线上那份是手工 gcc 链的、
+# 没有这个口子。这里把那个冒号就地改成字符串终止符：长度不变、ELF 结构不动，等价于
+# `chrpath -d` 的收缩改写（chrpath/patchelf 本机都没有）。只在真的出现时才改写。
+
+strip_empty_rpath_entry() {
+    local binary="$1"
+    [ -f "$binary" ] || return 0
+    command -v python3 >/dev/null 2>&1 || return 0
+    python3 - "$binary" <<'PY'
+import sys
+path = sys.argv[1]
+needle = b"$ORIGIN/third_party/libuvc:\x00"
+fixed = b"$ORIGIN/third_party/libuvc\x00\x00"
+with open(path, "rb") as handle:
+    data = handle.read()
+if needle not in data:
+    sys.exit(0)
+with open(path, "wb") as handle:
+    handle.write(data.replace(needle, fixed))
+print(f"  去掉 RUNPATH 空条目: {path}")
+PY
+}
+
+for binary in ksq-camera-service discover-uvc-config sonix-flash-probe; do
+    strip_empty_rpath_entry "$BUILD/$binary"
+done
+
+# ---------------------------------------------------------------- 校验
+#
+# 产物必须链上 libuvc.so.0 且 RUNPATH 为 $ORIGIN/third_party/libuvc —— 部署布局
+# 靠的就是这个相对路径（ksq-camera-service 里 libusb_reset_device 是 dlsym 取的，
+# 所以它自己 NEEDED 里没有 libusb，libuvc 带进来就够）。
+
+for binary in ksq-camera-service discover-uvc-config; do
+    [ -x "$BUILD/$binary" ] || die "没有产出 $BUILD/$binary"
+    if command -v readelf >/dev/null 2>&1; then
+        readelf -d "$BUILD/$binary" | grep -q 'libuvc.so.0' \
+            || die "$binary 没有链接 libuvc.so.0"
+        readelf -d "$BUILD/$binary" | grep -q '\$ORIGIN/third_party/libuvc' \
+            || die "$binary 的 RUNPATH 不是 \$ORIGIN/third_party/libuvc"
+        readelf -d "$BUILD/$binary" | grep -q 'libuvc:' \
+            && die "$binary 的 RUNPATH 里还有空条目（strip_empty_rpath_entry 没生效）"
+    fi
+done
+readelf -d "$BUILD/third_party/libuvc/libuvc.so.0.0.7" 2>/dev/null | grep -q libjpeg \
+    && echo "libuvc: 带 libjpeg（支持 MJPEG 解码）" \
+    || echo "警告: libuvc 没链上 libjpeg —— 不带 MJPEG 解码，与线上产物不一致" >&2
+
+if [ "$DO_TEST" = 1 ]; then
+    # 走 ctest 而不是点名跑某一个：以前这里写死跑 test-frame-integrity，
+    # 结果 test-altsetting-ladder 虽然在 CMakeLists 里注册了 add_test，却
+    # 从来没有被任何入口调起来 —— 降档梯子是真机上最难复现、最该靠测试
+    # 兜住的一块，却一直没人跑。新增测试只要 add_test 就自动纳进来。
+    echo "--- ctest ---"
+    ( cd "$BUILD" && ctest --output-on-failure )
+fi
+
+if [ "$DO_INSTALL" = 0 ]; then
+    echo "已完成构建（--no-install，未改动 core/gripper/native/）"
+    exit 0
+fi
+
+# ---------------------------------------------------------------- 安装
+#
+# 旧的同名二进制按 .pre_rebuild_<时间戳> 备份，保留现场可比对（历史上这里存过
+# pre_stall_watchdog / pre_usb_reset_escalation 两份，都是用来回退的）。
+
+[ -d "$OUT" ] || die "安装目标不存在: $OUT"
+
+STAMP="$(date +%Y%m%d_%H%M%S)"
+for binary in ksq-camera-service discover-uvc-config sonix-flash-probe; do
+    [ -f "$BUILD/$binary" ] || continue
+    if [ -f "$OUT/$binary" ]; then
+        cp -p "$OUT/$binary" "$OUT/$binary.pre_rebuild_$STAMP"
+    fi
+    cp -p "$BUILD/$binary" "$OUT/$binary"
+    echo "安装 $binary → $OUT/$binary"
+done
+
+mkdir -p "$OUT/third_party/libuvc"
+for name in libuvc.so libuvc.so.0 libuvc.so.0.0.7; do
+    [ -e "$BUILD/third_party/libuvc/$name" ] || continue
+    rm -f "$OUT/third_party/libuvc/$name"
+    cp -a "$BUILD/third_party/libuvc/$name" "$OUT/third_party/libuvc/$name"
+done
+rm -rf "$OUT/third_party/libuvc/include"
+cp -a "$BUILD/third_party/libuvc/include" "$OUT/third_party/libuvc/include"
+echo "安装 libuvc → $OUT/third_party/libuvc/"
+
+echo
+echo "完成。回退：把 $OUT/<名字>.pre_rebuild_$STAMP 覆盖回去即可。"

collector/core/gripper/camera_service_src/src/camera_service.c

@@ -0,0 +1,1514 @@
+/* pthread_timedjoin_np 是 GNU 扩展，必须在任何头文件之前打开。 */
+#define _GNU_SOURCE
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <poll.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <sys/uio.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <libuvc/libuvc.h>
+
+#include <dlfcn.h>
+#include <pthread.h>
+
+#define MAX_CAMERAS 8
+#define FRAME_QUEUE_DEPTH 4
+#define MAX_LINE 512
+#define IPC_MAGIC 0x4b535146u /* "KSQF" */
+#define IPC_VERSION 1u
+/* 等时流静默停摆看门狗。DECXIN (1bcf:2d4f) 会在 6~82 秒之间无声停止推帧，
+ * 此后永不恢复，内核也不报任何错误（实测：同一总线同一 Hub 上的两路
+ * Sightac 全程 30fps 正常，只有 DECXIN 自己死）。停滞不是「暂时掉帧」：
+ * libuvc 丢完等时包后不会自愈，必须重开流。停滞超过这个秒数就中断本路，
+ * 交给 camera_main 的重试循环重开——否则整场会话只剩最后一帧，客户端
+ * 重连也只能重连进空气。 */
+#define STREAM_STALL_TIMEOUT_SECONDS 3.0
+
+/* 首次启动等首帧的时限（秒）。 */
+#define FIRST_FRAME_TIMEOUT_SECONDS 4.0
+/* 停摆重开时等首帧的时限（秒）。实测 DECXIN 被拆流后不会立刻回来，
+ * 4 秒内一帧都没有（会被误判成 startup failed 再拆一次，越拆越糟），
+ * 放宽到 20 秒再判死。 */
+#define RESTART_FIRST_FRAME_TIMEOUT_SECONDS 20.0
+
+/* 连着停摆几次才降档。
+ *
+ * 设成 2 而不是 1：单次停摆多半只是设备自己抽了一下——实测停摆 6 次里每次
+ * 单靠重建 libusb 上下文就能恢复；一停就降会把 alt7 的带宽白白让出去，而
+ * alt6 的单帧上限只有 241664 B（实测最大帧 234148 B，3% 余量），降下去是有
+ * 代价的。两次说明当前档位确实撑不住：实测 alt7 在整机三路出流时每 45~130 秒
+ * 必停一次（AMD 1022:15b7 / PCI 0000:74:00.4，以及 1022:43fc / PCI
+ * 0000:0a:00.0，两块都是），两次最多赔 260 秒，且结论会落盘，每台机器只赔这
+ * 一回。 */
+#define STALLS_BEFORE_ALTSETTING_DOWNGRADE 2
+
+/* 开不起来（rc<0）连着几次才降档。
+ *
+ * 与停摆分开计、门槛也更高：开不起来多半是设备侧卡死，而那有自己的一条恢复
+ * 路径（连续 2 次失败升级成 USB 复位，实测 t≈3 秒就能出帧），一开不起来就降
+ * 档会在正常恢复路径上白降。门槛 3 意味着复位试过、还是开不起来，档位才是
+ * 剩下的嫌疑。要覆盖的是另一种失败：STREAMON 阶段就排不下高带宽等时档
+ * （libusb_set_interface_alt_setting 报 -ENOSPC），此时流根本不会启动，
+ * 光靠停摆那条路永远等不到。 */
+#define OPEN_FAILURES_BEFORE_ALTSETTING_DOWNGRADE 3
+
+/* 一段流稳定跑够这么久，就把「本档位停摆计数」清零。
+ * 要比实测的停摆间隔（45~130 秒）明显长，否则计数永远清不掉。 */
+#define CLEAN_RUN_SECONDS 300.0
+
+/* 复位 USB 设备（等价于拔插一次）。只在一个场合用：重开之后一帧都没有，
+ * 说明设备侧真的卡住了（典型是上一次服务被 SIGKILL、设备停在激活的等时
+ * alt setting 上），只重建上下文救不回来。
+ *
+ * 平时停摆恢复**不要**走这里：复位是 USB 端口级操作，会重新枚举整条链路，
+ * 连带打扰同一总线同一 Hub 上的另外两路 Sightac（实测每次复位两个 Sightac
+ * 都掉一批帧）。实测停摆 6 次只用「重建 libusb 上下文」就 6 次全恢复，复位
+ * 是白付的代价。
+ *
+ * libusb 是 libuvc 的依赖、进程里必然已加载，所以按符号名取而不是直接链接
+ * ——这样不给二进制新增 NEEDED，交付树里 libuvc/libusb 的解析结果不变。 */
+typedef int (*libusb_reset_device_fn)(struct libusb_device_handle *);
+
+static libusb_reset_device_fn resolve_libusb_reset_device(void) {
+    static libusb_reset_device_fn cached = NULL;
+    static int resolved = 0;
+    if (!resolved) {
+        cached = (libusb_reset_device_fn)dlsym(RTLD_DEFAULT,
+                                               "libusb_reset_device");
+        resolved = 1;
+    }
+    return cached;
+}
+
+static volatile sig_atomic_t g_stop = 0;
+static int g_parent_pid = 0;
+
+typedef struct {
+    char name[64];
+    int vid;
+    int pid;
+    int usb_bus;
+    char usb_port_path[64];
+    int streaming_interface;
+    /* 实际生效的等时档位。这两项不是「声明」——run_camera_once 打开设备后
+     * 会把它们交给 libuvc 的 uvc_set_altsetting_override()，由它同时决定
+     * COMMIT 的 payload 和 libusb 的等时传输几何。留空（-1）时退回 libuvc
+     * 的编译期兜底表。 */
+    int forced_altsetting;
+    int forced_payload;
+    int width;
+    int height;
+    int fps;
+    char format[16];
+    /* 相机的 USB 序列号、所在控制器的 PCI 路径、以及学习结果的存放目录。
+     * 三者只用来给「这台相机 × 这条物理路径」的档位选择建一个稳定的键，
+     * 见 mode_state_key()。控制器只进键、不参与选档。 */
+    char usb_serial[64];
+    char usb_controller[64];
+    char state_dir[PATH_MAX];
+    char socket_path[PATH_MAX];
+} camera_config_t;
+
+typedef struct {
+    uint32_t magic;
+    uint16_t version;
+    uint16_t header_bytes;
+    uint32_t sequence;
+    uint32_t width;
+    uint32_t height;
+    uint32_t fourcc;
+    uint32_t payload_bytes;
+    uint64_t timestamp_ns;
+} ipc_frame_header_t;
+
+typedef struct {
+    uint8_t *data;
+    size_t length;
+    uint32_t sequence;
+    uint64_t capture_timestamp_ns;
+} frame_item_t;
+
+typedef struct camera_state camera_state_t;
+
+struct camera_state {
+    camera_config_t config;
+    pthread_t thread;
+    pthread_t writer_thread;
+    pthread_mutex_t mutex;
+    pthread_cond_t condition;
+    frame_item_t queue[FRAME_QUEUE_DEPTH];
+    size_t head;
+    size_t count;
+    int stopping;
+    int listen_fd;
+    int client_fd;
+    uint64_t frames_received;
+    uint64_t frames_output;
+    uint64_t frames_dropped;
+    uint64_t bad_jpeg_frames;
+    uint64_t bad_jpeg_logs;
+    uint64_t bad_jpeg_replaced;
+    uint64_t write_errors;
+    uint64_t reconnects;
+    uint64_t stalls;
+    /* 当前档位下已经停摆了几次，连着停够 STALLS_BEFORE_ALTSETTING_DOWNGRADE
+     * 次就降到下一档；中间只要有一段够长的稳定运行就清零（那次停摆是设备
+     * 自己抽了一下，不是档位撑不住）。 */
+    unsigned stalls_at_mode;
+    /* 当前档位下连着几次没能把流开起来（rc<0）。任何一次「开起来了」的证据
+     * 都会清零它——停摆也算，因为停摆说明设备是开得起来的。 */
+    unsigned open_failures_at_mode;
+    /* 连续「开不起来」的次数（rc<0）。与 stalls 分开计：停摆说明设备能开、
+     * 能出帧，只是中途死了；连续开不起来才是设备侧卡死的signature。 */
+    unsigned hard_failures;
+    unsigned usb_resets;
+
+};
+
+static int has_mjpeg_soi(const uint8_t *data, size_t length) {
+    return length >= 2 && data[0] == 0xff && data[1] == 0xd8;
+}
+
+static int has_mjpeg_eoi(const uint8_t *data, size_t length) {
+    /* Some firmware variants append padding after the EOI marker, so scan
+     * backwards instead of requiring the final two bytes to be exactly
+     * FF D9.  A truncated scan will not contain the marker at all. */
+    for (size_t index = length; index >= 2; --index) {
+        if (data[index - 2] == 0xff && data[index - 1] == 0xd9) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static int is_complete_mjpeg_payload(const uint8_t *data, size_t length) {
+    return has_mjpeg_soi(data, length) && has_mjpeg_eoi(data, length);
+}
+
+static void request_stop(int signal_number) {
+    (void)signal_number;
+    g_stop = 1;
+}
+
+static char *trim(char *value) {
+    char *end;
+    while (*value == ' ' || *value == '\t' || *value == '\r' ||
+           *value == '\n') {
+        ++value;
+    }
+    end = value + strlen(value);
+    while (end > value && (end[-1] == ' ' || end[-1] == '\t' ||
+                           end[-1] == '\r' || end[-1] == '\n')) {
+        --end;
+    }
+    *end = '\0';
+    return value;
+}
+
+static int parse_int(const char *value, int *result) {
+    char *end = NULL;
+    long parsed;
+    errno = 0;
+    parsed = strtol(value, &end, 0);
+    if (errno != 0 || end == value || *trim(end) != '\0' ||
+        parsed < INT_MIN || parsed > INT_MAX) {
+        return -1;
+    }
+    *result = (int)parsed;
+    return 0;
+}
+
+static void set_defaults(camera_config_t *config) {
+    memset(config, 0, sizeof(*config));
+    config->usb_bus = -1;
+    config->streaming_interface = 1;
+    config->forced_altsetting = -1;
+    config->forced_payload = -1;
+    config->width = 640;
+    config->height = 480;
+    config->fps = 30;
+    snprintf(config->format, sizeof(config->format), "MJPEG");
+}
+
+static int assign_key(camera_config_t *config, const char *key,
+                      const char *value) {
+    if (strcmp(key, "vid") == 0) {
+        return parse_int(value, &config->vid);
+    }
+    if (strcmp(key, "pid") == 0) {
+        return parse_int(value, &config->pid);
+    }
+    if (strcmp(key, "usb_bus") == 0) {
+        return parse_int(value, &config->usb_bus);
+    }
+    if (strcmp(key, "streaming_interface") == 0) {
+        return parse_int(value, &config->streaming_interface);
+    }
+    if (strcmp(key, "forced_altsetting") == 0) {
+        return parse_int(value, &config->forced_altsetting);
+    }
+    if (strcmp(key, "forced_payload") == 0) {
+        return parse_int(value, &config->forced_payload);
+    }
+    if (strcmp(key, "width") == 0) {
+        return parse_int(value, &config->width);
+    }
+    if (strcmp(key, "height") == 0) {
+        return parse_int(value, &config->height);
+    }
+    if (strcmp(key, "fps") == 0) {
+        return parse_int(value, &config->fps);
+    }
+    if (strcmp(key, "usb_port_path") == 0) {
+        snprintf(config->usb_port_path, sizeof(config->usb_port_path),
+                 "%s", value);
+        return 0;
+    }
+    if (strcmp(key, "usb_serial") == 0) {
+        snprintf(config->usb_serial, sizeof(config->usb_serial), "%s", value);
+        return 0;
+    }
+    if (strcmp(key, "usb_controller") == 0) {
+        snprintf(config->usb_controller, sizeof(config->usb_controller),
+                 "%s", value);
+        return 0;
+    }
+    if (strcmp(key, "state_dir") == 0) {
+        snprintf(config->state_dir, sizeof(config->state_dir), "%s", value);
+        return 0;
+    }
+    if (strcmp(key, "socket_path") == 0) {
+        snprintf(config->socket_path, sizeof(config->socket_path), "%s", value);
+        return 0;
+    }
+    if (strcmp(key, "format") == 0) {
+        snprintf(config->format, sizeof(config->format),
+                 "%s", value);
+        return 0;
+    }
+    if (strcmp(key, "name") == 0) {
+        snprintf(config->name, sizeof(config->name), "%s", value);
+        return 0;
+    }
+    return 1;
+}
+
+static int is_supported_device(const camera_config_t *config) {
+    return (config->vid == 0x0c45 && config->pid == 0x636f) ||
+           (config->vid == 0x1bcf && config->pid == 0x2d4f);
+}
+
+/* 每个机型允许的「档位对」（altsetting, payload），按从好到差的顺序排列。
+ * 第 0 项是带宽最好的一档，停摆降级时往后走一格，走到最后一项就不再降
+ * ——**降级方向必须是从好到差，表序不能颠倒**。
+ *
+ * 这两张表必须与 libuvc 的编译期兜底表（third_party/libuvc/src/stream.c
+ * 的 ksq_altsetting_quirks）以及扫描程序（tools/discover_uvc_config.c 的
+ * profile_for）保持一致：libuvc 的表决定「没有覆盖值时的默认」，这里决定
+ * 「服务愿意接受哪些值」。
+ *
+ * **起始档位不在这张表里定**：起手用哪一档由 uvc_camera_service.py 的
+ * _starting_mode 写进 ini（表里最保守的一档，即最后一项），服务只负责接受
+ * 表内的值、并在反复停摆时降档。
+ *
+ * DECXIN 两档的账：alt7/1280 是 2 事务/微帧、10.24 MB/s，单帧上限 327680 B；
+ * alt6/944 是单事务档里最大的一档，8 transfer × 32 包 × 944 B = 241664 B 就是
+ * 单帧硬上限，而实测最大帧 234148 B——只剩 3% 余量。也就是说 alt7 的余量更
+ * 好看，但实测 alt7 在整机三路一起出流时每 45~130 秒必停摆一次，而 alt6 长跑
+ * 不停，**两档的出帧率完全一样（都 30.00fps）**——多出来的余量换不到任何看得
+ * 见的好处，所以默认就是 alt6。哪一档真的撑不住不靠推测，靠停摆实测往下走
+ * （见 maybe_downgrade_altsetting）。 */
+typedef struct {
+    int altsetting;
+    int payload;
+} altsetting_mode_t;
+
+static const altsetting_mode_t kSightacModes[] = {
+    {3, 800},
+};
+static const altsetting_mode_t kDecxinModes[] = {
+    {7, 1280},
+    {6, 944},
+};
+
+static const altsetting_mode_t *mode_table_for(const camera_config_t *config,
+                                               size_t *count) {
+    if (config->vid == 0x0c45 && config->pid == 0x636f) {
+        *count = sizeof(kSightacModes) / sizeof(kSightacModes[0]);
+        return kSightacModes;
+    }
+    if (config->vid == 0x1bcf && config->pid == 0x2d4f) {
+        *count = sizeof(kDecxinModes) / sizeof(kDecxinModes[0]);
+        return kDecxinModes;
+    }
+    *count = 0;
+    return NULL;
+}
+
+static size_t mode_index_for(const camera_config_t *config) {
+    size_t count = 0;
+    const altsetting_mode_t *modes = mode_table_for(config, &count);
+    for (size_t i = 0; i < count; ++i) {
+        if (modes[i].altsetting == config->forced_altsetting &&
+            modes[i].payload == config->forced_payload) {
+            return i;
+        }
+    }
+    return count;
+}
+
+/* 「这台相机 × 这条物理路径」的落盘键。
+ *
+ * 刻意不用总线号/端口路径：机架插在哪个口、哪条总线都不是永久的（用户
+ * 2026-09-15 明确说过 bus 1 不是永久的），端口一变键就变，要么把上一台
+ * 机器的结论套到新拓扑上，要么白学一遍。序列号取自相机描述符、随相机走；
+ * 控制器取自 PCI 路径、随插槽走。换电脑 / 换 USB 口都会得到新键，也就是
+ * 重新学一次——取保守的那一边：结论严格绑在学它的那条物理路径上。控制器
+ * 本身是不是变量并无定论（2026-09-15 实测 alt7 在 74:00.4 与 0a:00.0 上都
+ * 停摆），所以它只进键、不参与选档。
+ *
+ * Python 侧 core/gripper/devices/uvc_camera_service.py 用同一套规则造键去
+ * 查这个目录，两边的清洗规则必须逐字一致。 */
+static void mode_state_key(const camera_config_t *config, char *out,
+                           size_t size) {
+    char raw[192];
+    size_t written = 0;
+
+    snprintf(raw, sizeof(raw), "%04x_%04x_%s_%s", config->vid, config->pid,
+             config->usb_controller[0] != '\0' ? config->usb_controller
+                                               : "unknown",
+             config->usb_serial[0] != '\0' ? config->usb_serial : "noserial");
+    for (const char *cursor = raw; *cursor != '\0' && written + 1 < size;
+         ++cursor) {
+        char c = *cursor;
+        int safe = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+                   (c >= '0' && c <= '9') || c == '-';
+        out[written++] = safe ? c : '_';
+    }
+    out[written] = '\0';
+}
+
+/* 把学到的档位写进 state_dir，下次开机直接用它，不必再赔一次停摆窗口。
+ * 尽力而为：目录建不出来、盘写不进去都只记日志，绝不能因此让相机起不来。 */
+static void persist_mode_choice(const camera_state_t *camera) {
+    char key[200];
+    char path[PATH_MAX];
+    char temporary[PATH_MAX];
+    FILE *file;
+
+    if (camera->config.state_dir[0] == '\0') {
+        return;
+    }
+    mode_state_key(&camera->config, key, sizeof(key));
+    if (snprintf(path, sizeof(path), "%s/%s.mode", camera->config.state_dir,
+                 key) >= (int)sizeof(path) ||
+        snprintf(temporary, sizeof(temporary), "%s.tmp.%d", path,
+                 (int)getpid()) >= (int)sizeof(temporary)) {
+        fprintf(stderr, "[%s] state path too long; not persisting mode\n",
+                camera->config.name);
+        return;
+    }
+    if (mkdir(camera->config.state_dir, 0755) != 0 && errno != EEXIST) {
+        fprintf(stderr, "[%s] cannot create state dir %s: %s\n",
+                camera->config.name, camera->config.state_dir,
+                strerror(errno));
+        return;
+    }
+    file = fopen(temporary, "w");
+    if (file == NULL) {
+        fprintf(stderr, "[%s] cannot write %s: %s\n", camera->config.name,
+                temporary, strerror(errno));
+        return;
+    }
+    fprintf(file, "altsetting=%d\npayload=%d\n",
+            camera->config.forced_altsetting, camera->config.forced_payload);
+    fflush(file);
+    fsync(fileno(file));
+    fclose(file);
+    if (rename(temporary, path) != 0) {
+        fprintf(stderr, "[%s] cannot install %s: %s\n", camera->config.name,
+                path, strerror(errno));
+        unlink(temporary);
+        return;
+    }
+    fprintf(stderr, "[%s] remembered altsetting=%d payload=%d for this "
+            "camera/controller in %s\n", camera->config.name,
+            camera->config.forced_altsetting, camera->config.forced_payload,
+            path);
+}
+
+static int validate_config(const camera_config_t *config, size_t index) {
+    if (config->name[0] == '\0' || config->vid <= 0 || config->pid <= 0 ||
+        config->usb_bus < 0 || config->usb_port_path[0] == '\0' ||
+        config->socket_path[0] == '\0' || config->streaming_interface < 0 ||
+        config->forced_altsetting < 0 || config->forced_payload <= 0 ||
+        config->width <= 0 || config->height <= 0 || config->fps <= 0 ||
+        strcasecmp(config->format, "MJPEG") != 0) {
+        fprintf(stderr, "invalid camera config at index %zu\n", index);
+        return -1;
+    }
+    if (!is_supported_device(config)) {
+        fprintf(stderr, "%s: unsupported UVC device %04x:%04x; only Sightac "
+                "0c45:636f and DECXIN 1bcf:2d4f are supported\n",
+                config->name, config->vid, config->pid);
+        return -1;
+    }
+    if (config->vid == 0x0c45 && config->pid == 0x636f &&
+        (config->width != 640 || config->height != 480 || config->fps != 30)) {
+        fprintf(stderr, "%s: unsupported Sightac mode; expected 640x480 "
+                "MJPEG@30\n", config->name);
+        return -1;
+    }
+    if (config->vid == 0x1bcf && config->pid == 0x2d4f &&
+        (config->width != 1280 || config->height != 960 || config->fps != 30)) {
+        fprintf(stderr, "%s: unsupported DECXIN mode; expected 1280x960 "
+                "MJPEG@30\n", config->name);
+        return -1;
+    }
+    /* 档位对必须整体命中表里某一项。只查「alt 在表里」是不够的：alt 和
+     * payload 是一个整体（alt7 的端点就是 1280 B/包），把 7 和 944 拼在
+     * 一起会让 libuvc 用 alt7 的端点去跑 944 的预算，而 944 只是 COMMIT
+     * 上写的数——2026-09-15 主程序连不上夹爪就是这两项被拆开配出来的。 */
+    {
+        size_t count = 0;
+        mode_table_for(config, &count);
+        if (mode_index_for(config) < count) {
+            return 0;
+        }
+    }
+    fprintf(stderr, "%s: unsupported altsetting pair alt=%d payload=%d; this "
+            "camera accepts only the pairs in the service's mode table\n",
+            config->name, config->forced_altsetting, config->forced_payload);
+    return -1;
+}
+
+static int configs_conflict(const camera_config_t *left,
+                            const camera_config_t *right) {
+    if (strcmp(left->socket_path, right->socket_path) == 0) {
+        return 1;
+    }
+    return left->vid == right->vid && left->pid == right->pid &&
+           left->usb_bus == right->usb_bus &&
+           strcmp(left->usb_port_path, right->usb_port_path) == 0;
+}
+
+static int load_config(const char *path, camera_config_t *configs,
+                       size_t *count) {
+    FILE *file;
+    char line[MAX_LINE];
+    camera_config_t *current = NULL;
+    size_t index = 0;
+
+    file = fopen(path, "r");
+    if (file == NULL) {
+        fprintf(stderr, "cannot open config %s: %s\n", path, strerror(errno));
+        return -1;
+    }
+    while (fgets(line, sizeof(line), file) != NULL) {
+        char *text = trim(line);
+        char *equals;
+        if (*text == '\0' || *text == '#' || *text == ';') {
+            continue;
+        }
+        if (*text == '[') {
+            char *close = strchr(text, ']');
+            if (close == NULL || index >= MAX_CAMERAS) {
+                fclose(file);
+                return -1;
+            }
+            *close = '\0';
+            set_defaults(&configs[index]);
+            snprintf(configs[index].name, sizeof(configs[index].name),
+                     "%s", trim(text + 1));
+            current = &configs[index++];
+            continue;
+        }
+        if (current == NULL || (equals = strchr(text, '=')) == NULL) {
+            fclose(file);
+            return -1;
+        }
+        *equals = '\0';
+        {
+            char *key = trim(text);
+            char *value = trim(equals + 1);
+            char *comment = strchr(value, '#');
+            if (comment != NULL) {
+                *comment = '\0';
+                value = trim(value);
+            }
+            if (assign_key(current, key, value) < 0) {
+                fprintf(stderr, "invalid config value %s=%s\n", key, value);
+                fclose(file);
+                return -1;
+            }
+        }
+    }
+    fclose(file);
+    if (index == 0 || index > MAX_CAMERAS) {
+        return -1;
+    }
+    for (size_t i = 0; i < index; ++i) {
+        if (validate_config(&configs[i], i) != 0) {
+            return -1;
+        }
+        for (size_t j = 0; j < i; ++j) {
+            if (configs_conflict(&configs[i], &configs[j])) {
+                fprintf(stderr,
+                        "camera config conflict between %s and %s "
+                        "(duplicate output or USB identity)\n",
+                        configs[j].name, configs[i].name);
+                return -1;
+            }
+        }
+    }
+    *count = index;
+    return 0;
+}
+
+static int uvc_port_path(uvc_device_t *device, char *buffer,
+                         size_t buffer_size) {
+    uint8_t ports[8];
+    int count;
+    size_t used = 0;
+    count = uvc_get_port_numbers(device, ports, sizeof(ports));
+    if (count < 0) {
+        return -1;
+    }
+    buffer[0] = '\0';
+    for (int i = 0; i < count; ++i) {
+        int written = snprintf(buffer + used, buffer_size - used, "%s%u",
+                               i == 0 ? "" : ".", ports[i]);
+        if (written < 0 || (size_t)written >= buffer_size - used) {
+            return -1;
+        }
+        used += (size_t)written;
+    }
+    return 0;
+}
+
+static uvc_error_t open_matching_device(uvc_context_t *context,
+                                        const camera_config_t *config,
+                                        uvc_device_handle_t **result,
+                                        char *actual_path,
+                                        size_t actual_path_size) {
+    uvc_device_t **list = NULL;
+    uvc_error_t error;
+    *result = NULL;
+    error = uvc_get_device_list(context, &list);
+    if (error != UVC_SUCCESS) {
+        return error;
+    }
+    for (size_t i = 0; list[i] != NULL; ++i) {
+        uvc_device_descriptor_t *descriptor = NULL;
+        uvc_device_handle_t *candidate = NULL;
+        error = uvc_get_device_descriptor(list[i], &descriptor);
+        if (error != UVC_SUCCESS || descriptor == NULL ||
+            descriptor->idVendor != (uint16_t)config->vid ||
+            descriptor->idProduct != (uint16_t)config->pid ||
+            (int)uvc_get_bus_number(list[i]) != config->usb_bus) {
+            uvc_free_device_descriptor(descriptor);
+            continue;
+        }
+        if (uvc_port_path(list[i], actual_path, actual_path_size) != 0 ||
+            strcmp(actual_path, config->usb_port_path) != 0) {
+            uvc_free_device_descriptor(descriptor);
+            continue;
+        }
+        error = uvc_open(list[i], &candidate);
+        uvc_free_device_descriptor(descriptor);
+        if (error != UVC_SUCCESS || candidate == NULL) {
+            fprintf(stderr, "[%s] matched bus=%d port=%s open failed: %s (%d)\n",
+                    config->name, config->usb_bus, actual_path,
+                    uvc_strerror(error), error);
+            uvc_free_device_list(list, 1);
+            return error == UVC_SUCCESS ? UVC_ERROR_IO : error;
+        }
+        *result = candidate;
+        uvc_free_device_list(list, 1);
+        return UVC_SUCCESS;
+    }
+    uvc_free_device_list(list, 1);
+    return UVC_ERROR_NO_DEVICE;
+}
+
+static uint64_t timespec_nanoseconds(struct timespec value) {
+    if (value.tv_sec < 0 || value.tv_nsec < 0 || value.tv_nsec >= 1000000000L) {
+        return 0;
+    }
+    return (uint64_t)value.tv_sec * 1000000000ull +
+           (uint64_t)value.tv_nsec;
+}
+
+static int configure_ipc(camera_state_t *camera) {
+    struct sockaddr_un address;
+    mode_t old_umask;
+    size_t path_length = strlen(camera->config.socket_path);
+
+    if (path_length >= sizeof(address.sun_path)) {
+        fprintf(stderr, "[%s] Unix socket path is too long: %s\n",
+                camera->config.name, camera->config.socket_path);
+        return -1;
+    }
+    /*
+     * Use a byte-stream Unix socket instead of SOCK_SEQPACKET.  A DECXIN
+     * MJPEG frame can exceed the kernel's AF_UNIX packet-size limit; a
+     * length-bearing stream header avoids EMSGSIZE while retaining one
+     * complete frame per read_packet() at the protocol level.
+     */
+    camera->listen_fd = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (camera->listen_fd < 0) {
+        fprintf(stderr, "[%s] create Unix socket failed: %s\n",
+                camera->config.name, strerror(errno));
+        return -1;
+    }
+    memset(&address, 0, sizeof(address));
+    address.sun_family = AF_UNIX;
+    memcpy(address.sun_path, camera->config.socket_path, path_length + 1);
+    unlink(camera->config.socket_path);
+    old_umask = umask(0);
+    if (bind(camera->listen_fd, (struct sockaddr *)&address,
+             sizeof(address)) < 0) {
+        umask(old_umask);
+        fprintf(stderr, "[%s] bind Unix socket %s failed: %s\n",
+                camera->config.name, camera->config.socket_path,
+                strerror(errno));
+        close(camera->listen_fd);
+        camera->listen_fd = -1;
+        return -1;
+    }
+    umask(old_umask);
+    if (chmod(camera->config.socket_path, 0666) != 0 ||
+        listen(camera->listen_fd, 1) != 0) {
+        fprintf(stderr, "[%s] prepare Unix socket %s failed: %s\n",
+                camera->config.name, camera->config.socket_path,
+                strerror(errno));
+        close(camera->listen_fd);
+        camera->listen_fd = -1;
+        unlink(camera->config.socket_path);
+        return -1;
+    }
+    fprintf(stderr, "[%s] IPC socket=%s format=MJPEG size=%dx%d fps=%d\n",
+            camera->config.name, camera->config.socket_path,
+            camera->config.width, camera->config.height, camera->config.fps);
+    return 0;
+}
+
+static int accept_ipc_client(camera_state_t *camera) {
+    while (!g_stop && camera->client_fd < 0) {
+        struct pollfd descriptor = {
+            .fd = camera->listen_fd,
+            .events = POLLIN,
+            .revents = 0,
+        };
+        int ready = poll(&descriptor, 1, 500);
+        if (ready < 0 && errno == EINTR) {
+            continue;
+        }
+        if (ready <= 0) {
+            continue;
+        }
+        camera->client_fd = accept(camera->listen_fd, NULL, NULL);
+        if (camera->client_fd < 0 && errno != EINTR) {
+            return errno;
+        }
+    }
+    return camera->client_fd >= 0 ? 0 : ECANCELED;
+}
+
+static int send_all(int fd, const void *data, size_t length) {
+    const uint8_t *cursor = (const uint8_t *)data;
+    while (length > 0) {
+        ssize_t sent = send(fd, cursor, length, MSG_NOSIGNAL);
+        if (sent < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
+            return errno;
+        }
+        if (sent == 0) {
+            return EPIPE;
+        }
+        cursor += (size_t)sent;
+        length -= (size_t)sent;
+    }
+    return 0;
+}
+
+static int write_frame(camera_state_t *camera, const frame_item_t *item) {
+    ipc_frame_header_t header;
+    int error;
+
+    if (accept_ipc_client(camera) != 0) {
+        return g_stop ? ECANCELED : ENOTCONN;
+    }
+    memset(&header, 0, sizeof(header));
+    header.magic = IPC_MAGIC;
+    header.version = IPC_VERSION;
+    header.header_bytes = (uint16_t)sizeof(header);
+    header.sequence = item->sequence;
+    header.width = (uint32_t)camera->config.width;
+    header.height = (uint32_t)camera->config.height;
+    header.fourcc = (uint32_t)('M' | ('J' << 8) | ('P' << 16) | ('G' << 24));
+    header.payload_bytes = (uint32_t)item->length;
+    /*
+     * Preserve the timestamp assigned by libuvc when the complete UVC frame
+     * was received.  The socket writer can run later (or burst after a
+     * client connects), so send time would measure IPC scheduling rather than
+     * camera acquisition cadence.
+     */
+    header.timestamp_ns = item->capture_timestamp_ns;
+
+    error = send_all(camera->client_fd, &header, sizeof(header));
+    if (error == 0) {
+        error = send_all(camera->client_fd, item->data, item->length);
+    }
+    /* Any partial write invalidates byte-stream framing, including timeout. */
+    if (error != 0) {
+        close(camera->client_fd);
+        camera->client_fd = -1;
+    }
+    return error;
+}
+
+static void enqueue_frame(uvc_frame_t *frame, camera_state_t *camera) {
+    uint8_t *copy;
+    size_t tail;
+    uint64_t capture_timestamp_ns;
+    uint8_t *source = NULL;
+    size_t source_length = 0;
+    uint32_t source_sequence = 0;
+    if (frame == NULL || frame->data == NULL || frame->data_bytes == 0 ||
+        frame->frame_format != UVC_FRAME_FORMAT_MJPEG) {
+        return;
+    }
+    if (!is_complete_mjpeg_payload(frame->data, frame->data_bytes)) {
+        int should_log;
+        uint64_t bad_count;
+        pthread_mutex_lock(&camera->mutex);
+        camera->bad_jpeg_frames++;
+        camera->bad_jpeg_logs++;
+        camera->frames_dropped++;
+        bad_count = camera->bad_jpeg_frames;
+        should_log = bad_count == 1 || camera->bad_jpeg_logs % 100 == 0;
+        pthread_mutex_unlock(&camera->mutex);
+        if (should_log) {
+            fprintf(stderr,
+                    "[%s] dropped incomplete MJPEG sequence=%u bytes=%zu "
+                    "bad=%llu\n",
+                    camera->config.name, frame->sequence, frame->data_bytes,
+                    (unsigned long long)bad_count);
+        }
+        /* Never fabricate a new sample from an older image.  The sequence
+         * gap is intentional and preserves honest acquisition timestamps. */
+        return;
+    }
+    source = frame->data;
+    source_length = frame->data_bytes;
+    source_sequence = frame->sequence;
+    capture_timestamp_ns = timespec_nanoseconds(frame->capture_time_finished);
+    if (capture_timestamp_ns == 0) {
+        pthread_mutex_lock(&camera->mutex);
+        camera->frames_dropped++;
+        pthread_mutex_unlock(&camera->mutex);
+        return;
+    }
+    copy = malloc(source_length);
+    if (copy == NULL) {
+        pthread_mutex_lock(&camera->mutex);
+        camera->frames_dropped++;
+        pthread_mutex_unlock(&camera->mutex);
+        return;
+    }
+    memcpy(copy, source, source_length);
+    pthread_mutex_lock(&camera->mutex);
+    if (camera->stopping) {
+        free(copy);
+        pthread_mutex_unlock(&camera->mutex);
+        return;
+    }
+    if (camera->count == FRAME_QUEUE_DEPTH) {
+        free(camera->queue[camera->head].data);
+        camera->head = (camera->head + 1) % FRAME_QUEUE_DEPTH;
+        camera->count--;
+        camera->frames_dropped++;
+    }
+    tail = (camera->head + camera->count) % FRAME_QUEUE_DEPTH;
+    camera->queue[tail].data = copy;
+    camera->queue[tail].length = source_length;
+    camera->queue[tail].sequence = source_sequence;
+    camera->queue[tail].capture_timestamp_ns = capture_timestamp_ns;
+    camera->count++;
+    camera->frames_received++;
+
+    pthread_cond_signal(&camera->condition);
+    pthread_mutex_unlock(&camera->mutex);
+}
+
+static void frame_callback(uvc_frame_t *frame, void *user_ptr) {
+    enqueue_frame(frame, (camera_state_t *)user_ptr);
+}
+
+static void *writer_main(void *user_ptr) {
+    camera_state_t *camera = (camera_state_t *)user_ptr;
+    for (;;) {
+        frame_item_t item;
+        memset(&item, 0, sizeof(item));
+        pthread_mutex_lock(&camera->mutex);
+        while (camera->count == 0 && !camera->stopping) {
+            pthread_cond_wait(&camera->condition, &camera->mutex);
+        }
+        if (camera->count == 0 && camera->stopping) {
+            pthread_mutex_unlock(&camera->mutex);
+            break;
+        }
+        item = camera->queue[camera->head];
+        camera->queue[camera->head].data = NULL;
+        camera->head = (camera->head + 1) % FRAME_QUEUE_DEPTH;
+        camera->count--;
+        pthread_mutex_unlock(&camera->mutex);
+
+        int write_error = write_frame(camera, &item);
+        if (write_error == 0) {
+            pthread_mutex_lock(&camera->mutex);
+            camera->frames_output++;
+            pthread_mutex_unlock(&camera->mutex);
+        } else if (write_error == ECANCELED && g_stop) {
+            /* Normal shutdown: do not report queued frames canceled by the
+             * stop signal as an output failure. */
+        } else {
+            pthread_mutex_lock(&camera->mutex);
+            camera->write_errors++;
+            pthread_mutex_unlock(&camera->mutex);
+            fprintf(stderr, "[%s] output write failed: %s (%d)\n",
+                    camera->config.name, strerror(write_error), write_error);
+        }
+        free(item.data);
+    }
+    return NULL;
+}
+
+static double monotonic_seconds(void) {
+    struct timespec now;
+    if (clock_gettime(CLOCK_MONOTONIC, &now) != 0) {
+        return 0.0;
+    }
+    return (double)now.tv_sec + (double)now.tv_nsec / 1000000000.0;
+}
+
+static void report_stats(camera_state_t *camera, double elapsed,
+                         uint64_t previous_received,
+                         uint64_t previous_output,
+                         uint64_t previous_dropped,
+                         uint64_t previous_bad_jpeg) {
+    uint64_t received;
+    uint64_t output;
+    uint64_t dropped;
+    uint64_t bad_jpeg;
+    uint64_t bad_replaced;
+    uint64_t write_errors;
+    size_t queued;
+
+    pthread_mutex_lock(&camera->mutex);
+    received = camera->frames_received;
+    output = camera->frames_output;
+    dropped = camera->frames_dropped;
+    bad_jpeg = camera->bad_jpeg_frames;
+    bad_replaced = camera->bad_jpeg_replaced;
+    write_errors = camera->write_errors;
+    queued = camera->count;
+    pthread_mutex_unlock(&camera->mutex);
+    if (elapsed <= 0.0) {
+        return;
+    }
+    fprintf(stderr,
+            "[%s] fps_in=%.2f fps_out=%.2f received=%llu output=%llu "
+            "dropped=%llu (+%llu) bad_jpeg=%llu (+%llu) "
+            "bad_replaced=%llu write_errors=%llu queue=%zu\n",
+            camera->config.name,
+            (double)(received - previous_received) / elapsed,
+            (double)(output - previous_output) / elapsed,
+            (unsigned long long)received, (unsigned long long)output,
+            (unsigned long long)dropped,
+            (unsigned long long)(dropped - previous_dropped),
+            (unsigned long long)bad_jpeg,
+            (unsigned long long)(bad_jpeg - previous_bad_jpeg),
+            (unsigned long long)bad_replaced,
+            (unsigned long long)write_errors, queued);
+}
+
+static void close_ipc(camera_state_t *camera) {
+    pthread_mutex_lock(&camera->mutex);
+    camera->stopping = 1;
+    pthread_cond_broadcast(&camera->condition);
+    pthread_mutex_unlock(&camera->mutex);
+    if (camera->writer_thread != 0) {
+        pthread_join(camera->writer_thread, NULL);
+        camera->writer_thread = 0;
+    }
+    for (size_t i = 0; i < FRAME_QUEUE_DEPTH; ++i) {
+        free(camera->queue[i].data);
+        camera->queue[i].data = NULL;
+    }
+    camera->head = 0;
+    camera->count = 0;
+    if (camera->client_fd >= 0) {
+        close(camera->client_fd);
+        camera->client_fd = -1;
+    }
+    if (camera->listen_fd >= 0) {
+        close(camera->listen_fd);
+        camera->listen_fd = -1;
+    }
+    unlink(camera->config.socket_path);
+}
+
+static void reset_usb_device(camera_state_t *camera,
+                             uvc_device_handle_t *device) {
+    struct libusb_device_handle *usb_handle = uvc_get_libusb_handle(device);
+    libusb_reset_device_fn reset_device = resolve_libusb_reset_device();
+    if (usb_handle == NULL || reset_device == NULL) {
+        fprintf(stderr,
+                "[%s] cannot reset device (handle=%p symbol=%p)\n",
+                camera->config.name, (void *)usb_handle, (void *)reset_device);
+        return;
+    }
+    int reset_rc = reset_device(usb_handle);
+    fprintf(stderr, "[%s] usb reset: rc=%d (%s)\n", camera->config.name,
+            reset_rc, uvc_strerror(reset_rc));
+}
+
+/* 上一次复位之后留给客户端的余量：客户端只等 10 秒就把服务收掉，所以
+ * 「第几次失败才升级成复位」是拿这个窗口倒推出来的，不是拍的。
+ * 实测卡死设备的失败很快（每次约 0.3 秒 + 1 秒间隔），第 2 次失败触发
+ * 复位的时刻在 t≈2 秒，重枚举加重开约 1 秒，t≈3 秒就能出帧——10 秒够用。
+ * 门槛设成「连续 2 次」而不是「1 次」：单次失败往往只是设备还没缓过来
+ * （那种情况重建上下文就够，实测 6/6 全恢复），一失败就复位会白白打扰
+ * 同 Hub 的另外两路。
+ *
+ * 上限 USB_RESET_LIMIT 次：设备真坏了的时候，不设上限会变成每 2 秒复位
+ * 一次、把另外两路一直按在地上。打满就不再复位，退回普通重试。 */
+#define HARD_FAILURES_BEFORE_RESET 1
+#define USB_RESET_LIMIT 3
+
+/* 停摆够次数就退一档，并记住这次选择。
+ *
+ * 为什么要有这条路（而不是起手就用最保守档、或者按机器写死）：起手档已经
+ * 是最保守的那一档了，这条路是给**操作者手动把 ini 改成高带宽档**兜底的
+ * ——想要 alt7 那点每帧余量就改，真撑不住时服务停两次自己退回 alt6 并把结论
+ * 落盘，下次开机直接用，不用人去记哪台机器该用哪档。按机器写死则是另一回事：
+ * 机架插在哪条总线、哪台机器都不固定，写死要每台各配一份，而且写死的那个
+ * 判断（「这台控制器扛不扛得住」）本身就没被测准过——试错要便宜得多。
+ *
+ * 返回 1 表示已降档。 */
+static int maybe_downgrade_altsetting(camera_state_t *camera) {
+    size_t count = 0;
+    const altsetting_mode_t *modes = mode_table_for(&camera->config, &count);
+    size_t index = mode_index_for(&camera->config);
+
+    if (modes == NULL || index + 1 >= count) {
+        return 0;
+    }
+    camera->config.forced_altsetting = modes[index + 1].altsetting;
+    camera->config.forced_payload = modes[index + 1].payload;
+    /* 两个计数都要归零，各自对应一条降档触发路径。漏掉哪个，那条路就
+     * 只能降一次：stalls 由本函数清零，open_failures 若不清零，判等
+     * （== 门槛）在降档后永远不再成立，梯子在「开不起来」那条路上走
+     * 完一格就卡死，后两档形同不存在。 */
+    camera->stalls_at_mode = 0;
+    camera->open_failures_at_mode = 0;
+    persist_mode_choice(camera);
+    return 1;
+}
+
+static void escalate_to_usb_reset(camera_state_t *camera,
+                                  uvc_device_handle_t *device) {
+    if (camera->hard_failures < HARD_FAILURES_BEFORE_RESET) {
+        return;
+    }
+    if (camera->usb_resets >= USB_RESET_LIMIT) {
+        return;
+    }
+    camera->usb_resets++;
+    reset_usb_device(camera, device);
+}
+
+/* 失败路径的收尾。复位要抢在 uvc_stop_streaming 之前：
+ * 卡死的设备上 uvc_stop_streaming 会一直等它那批永远回不来的等时传输，
+ * 实测能卡满客户端那 2 秒宽限期、被 SIGKILL 打断——进程死在这中间，
+ * 设备就停在激活的 alt setting 上，下一轮启动照样起不来（用户 09:24
+ * 的日志正是断在 startup failed 与 usb reset 之间）。复位会取消在途
+ * 传输，先复位再停流，这条路径才走得完。 */
+static void teardown_failed_open(camera_state_t *camera,
+                                 uvc_device_handle_t *device) {
+    escalate_to_usb_reset(camera, device);
+    uvc_stop_streaming(device);
+    uvc_close(device);
+    close_ipc(camera);
+}
+
+static int run_camera_once(camera_state_t *camera, uvc_context_t *context) {
+    uvc_device_handle_t *device = NULL;
+    uvc_stream_ctrl_t control;
+    char actual_path[64] = {0};
+    uvc_error_t error;
+    double previous_report = monotonic_seconds();
+    uint64_t previous_received = 0;
+    uint64_t previous_output = 0;
+    uint64_t previous_dropped = 0;
+    uint64_t previous_bad_jpeg = 0;
+
+    pthread_mutex_lock(&camera->mutex);
+    uint64_t initial_received = camera->frames_received;
+    /* 每次重开都要把上报基线对齐到当前累计值。留在 0 会让重开后的第一次
+     * 上报把「进程启动至今的全部帧数」当成本窗口的增量，算出 200+fps 这种
+     * 假速率（纯日志问题，不影响出帧，但会把人带偏）。 */
+    previous_received = camera->frames_received;
+    previous_output = camera->frames_output;
+    previous_dropped = camera->frames_dropped;
+    previous_bad_jpeg = camera->bad_jpeg_frames;
+    camera->stopping = 0;
+    pthread_mutex_unlock(&camera->mutex);
+    error = open_matching_device(context, &camera->config, &device,
+                                 actual_path, sizeof(actual_path));
+    if (error != UVC_SUCCESS) {
+        fprintf(stderr, "[%s] device %04x:%04x bus=%d port=%s unavailable: %s\n",
+                camera->config.name, camera->config.vid, camera->config.pid,
+                camera->config.usb_bus, camera->config.usb_port_path,
+                uvc_strerror(error));
+        close_ipc(camera);
+        return -1;
+    }
+    /* 在协商之前把 ini 里的档位钉到设备句柄上。libuvc 自己的编译期表只是
+     * 兜底：真正决定用哪一档的是这份 ini，而 ini 里的值来自扫描程序实测的
+     * 端点描述符、或者上一轮学到的结论。 */
+    error = uvc_set_altsetting_override(device, camera->config.forced_altsetting,
+                                        (unsigned int)camera->config.forced_payload);
+    if (error != UVC_SUCCESS) {
+        fprintf(stderr, "[%s] cannot apply altsetting override alt=%d payload=%d: %s\n",
+                camera->config.name, camera->config.forced_altsetting,
+                camera->config.forced_payload, uvc_strerror(error));
+        teardown_failed_open(camera, device);
+        return -1;
+    }
+    memset(&control, 0, sizeof(control));
+    error = uvc_get_stream_ctrl_format_size(
+        device, &control, UVC_FRAME_FORMAT_MJPEG,
+        camera->config.width, camera->config.height, camera->config.fps);
+    if (error != UVC_SUCCESS ||
+        control.bInterfaceNumber != camera->config.streaming_interface) {
+        fprintf(stderr, "[%s] UVC format/interface negotiation failed: %s interface=%u expected=%d\n",
+                camera->config.name, uvc_strerror(error),
+                control.bInterfaceNumber, camera->config.streaming_interface);
+        teardown_failed_open(camera, device);
+        return -1;
+    }
+    fprintf(stderr,
+            "[%s] vidpid=%04x:%04x bus=%d port=%s interface=%u alt=%d payload=%d "
+            "format=MJPEG size=%dx%d fps=%d socket=%s negotiated_payload=%u\n",
+            camera->config.name, camera->config.vid, camera->config.pid,
+            camera->config.usb_bus, actual_path, control.bInterfaceNumber,
+            camera->config.forced_altsetting, camera->config.forced_payload,
+            camera->config.width, camera->config.height, camera->config.fps,
+            camera->config.socket_path, control.dwMaxPayloadTransferSize);
+    error = uvc_start_streaming(device, &control, frame_callback, camera, 0);
+    if (error != UVC_SUCCESS) {
+        fprintf(stderr, "[%s] uvc_start_streaming failed: %s\n",
+                camera->config.name, uvc_strerror(error));
+        teardown_failed_open(camera, device);
+        return -1;
+    }
+    /* Publish IPC only once MJPG negotiation, STREAMON and a valid frame
+     * have succeeded. Socket existence is a readiness promise to the parent. */
+    int first_frame = 0;
+    int restarting = camera->reconnects > 0;
+    double first_frame_timeout = restarting
+        ? RESTART_FIRST_FRAME_TIMEOUT_SECONDS : FIRST_FRAME_TIMEOUT_SECONDS;
+    double deadline = monotonic_seconds() + first_frame_timeout;
+    while (!g_stop && monotonic_seconds() < deadline) {
+        pthread_mutex_lock(&camera->mutex);
+        first_frame = camera->frames_received > initial_received;
+        pthread_mutex_unlock(&camera->mutex);
+        if (first_frame) break;
+        usleep(10000);
+    }
+    if (!first_frame || configure_ipc(camera) != 0) {
+        fprintf(stderr, "[%s] startup failed: no valid MJPG frame or IPC unavailable\n", camera->config.name);
+        teardown_failed_open(camera, device);
+        return -1;
+    }
+    if (pthread_create(&camera->writer_thread, NULL, writer_main, camera) != 0) {
+        fprintf(stderr, "[%s] writer thread creation failed\n", camera->config.name);
+        uvc_stop_streaming(device);
+        uvc_close(device);
+        close_ipc(camera);
+        return -1;
+    }
+    int stalled = 0;
+    double last_progress = monotonic_seconds();
+    double stream_started = last_progress;
+    int clean_run_credited = 0;
+    uint64_t last_received = 0;
+    pthread_mutex_lock(&camera->mutex);
+    last_received = camera->frames_received;
+    pthread_mutex_unlock(&camera->mutex);
+
+    while (!g_stop) {
+        sleep(1);
+        if (g_parent_pid > 1 && getppid() != g_parent_pid) {
+            fprintf(stderr,
+                    "[%s] parent %d exited; stopping stream\n",
+                    camera->config.name, g_parent_pid);
+            g_stop = 1;
+            break;
+        }
+        double now = monotonic_seconds();
+        if (now - previous_report >= 5.0) {
+            report_stats(camera, now - previous_report,
+                         previous_received, previous_output,
+                        previous_dropped, previous_bad_jpeg);
+            pthread_mutex_lock(&camera->mutex);
+            previous_received = camera->frames_received;
+            previous_output = camera->frames_output;
+            previous_dropped = camera->frames_dropped;
+            previous_bad_jpeg = camera->bad_jpeg_frames;
+            pthread_mutex_unlock(&camera->mutex);
+            previous_report = now;
+        }
+        /* 停滞看门狗：见 STREAM_STALL_TIMEOUT_SECONDS 的注释。这里不能
+         * 只等 g_stop——流死了 g_stop 永远不会置位，重试循环也就永远
+         * 轮不到，整路相机就此静默报废。 */
+        pthread_mutex_lock(&camera->mutex);
+        uint64_t received_now = camera->frames_received;
+        pthread_mutex_unlock(&camera->mutex);
+        /* 稳定跑够 CLEAN_RUN_SECONDS 就把本档位的停摆计数清零：说明这个档位
+         * 是撑得住的，之前那次停摆是设备自己抽了一下。 */
+        if (!clean_run_credited && now - stream_started >= CLEAN_RUN_SECONDS) {
+            clean_run_credited = 1;
+            camera->stalls_at_mode = 0;
+        }
+        if (received_now != last_received) {
+            last_received = received_now;
+            last_progress = now;
+        } else if (now - last_progress >= STREAM_STALL_TIMEOUT_SECONDS) {
+            pthread_mutex_lock(&camera->mutex);
+            camera->stalls++;
+            pthread_mutex_unlock(&camera->mutex);
+            fprintf(stderr,
+                    "[%s] stream stalled: no frame for %.1fs "
+                    "(received=%llu); restarting UVC stream\n",
+                    camera->config.name, now - last_progress,
+                    (unsigned long long)received_now);
+            stalled = 1;
+            break;
+        }
+    }
+    uvc_stop_streaming(device);
+    uvc_close(device);
+    close_ipc(camera);
+    /* 返回 0 会被 camera_main 当成正常收尾而退出重试循环；停摆用 +1 单独
+     * 标记，让 camera_main 知道还要重建 libusb 上下文。 */
+    return stalled ? 1 : 0;
+}
+
+static void *camera_main(void *user_ptr) {
+    camera_state_t *camera = (camera_state_t *)user_ptr;
+    uvc_context_t *context = NULL;
+    uvc_error_t error = uvc_init(&context, NULL);
+    if (error != UVC_SUCCESS) {
+        fprintf(stderr, "[%s] uvc_init failed: %s\n", camera->config.name,
+                uvc_strerror(error));
+        return NULL;
+    }
+    while (!g_stop) {
+        if (g_parent_pid > 1 && getppid() != g_parent_pid) {
+            fprintf(stderr,
+                    "[SUPERVISION] parent %d exited; stopping service\n",
+                    g_parent_pid);
+            g_stop = 1;
+            break;
+        }
+        int rc = run_camera_once(camera, context);
+        if (rc == 0) {
+            break;
+        }
+        camera->reconnects++;
+        if (rc > 0) {
+            /* 停摆那次是开得起来、出过帧的，设备侧没卡死；把连续失败清零，
+             * 免得几次停摆的失败凑够数、误触发 USB 复位去打扰另���两路。 */
+            camera->hard_failures = 0;
+            /* 开得起来 ⇒ 这个档位至少被控制器接受了，清掉开不起来的计数。 */
+            camera->open_failures_at_mode = 0;
+            /* 当前档位连着停够次数就退一档（并落盘）。降档要在重建上下文
+             * 之前生效——重开的流才会用新的 alt/payload。 */
+            camera->stalls_at_mode++;
+            if (camera->stalls_at_mode == STALLS_BEFORE_ALTSETTING_DOWNGRADE) {
+                /* 计数要在降档之前抓下来：maybe_downgrade_altsetting 成功时
+                 * 会把它清零，之后再读就只能打出「0 stalls」，正好把最该
+                 * 看的那次降级说成没有依据。 */
+                unsigned stalls = camera->stalls_at_mode;
+                int previous_alt = camera->config.forced_altsetting;
+                if (maybe_downgrade_altsetting(camera)) {
+                    fprintf(stderr,
+                            "[%s] %u stalls at alt=%d; dropping to alt=%d "
+                            "payload=%d\n",
+                            camera->config.name, stalls, previous_alt,
+                            camera->config.forced_altsetting,
+                            camera->config.forced_payload);
+                } else {
+                    fprintf(stderr,
+                            "[%s] %u stalls but alt=%d is already the lowest "
+                            "setting for this camera; staying put\n",
+                            camera->config.name, stalls,
+                            camera->config.forced_altsetting);
+                }
+            }
+            /* 停摆：同一个 libusb 上下文里的设备对象在复位后已经失效，
+             * 用它重开只会拿到一个永远不出帧的死句柄（表现为
+             * 「negotiated OK 但 20 秒一帧没有」）。新进程能恢复、同进程
+             * 重开不能，差别就在这里——重建上下文＝拿到与「新进程」等价
+             * 的干净枚举。 */
+            fprintf(stderr, "[%s] rebuilding libusb context after stall\n",
+                    camera->config.name);
+            uvc_exit(context);
+            context = NULL;
+            if (uvc_init(&context, NULL) != UVC_SUCCESS) {
+                fprintf(stderr, "[%s] uvc_init failed after stall; "
+                        "camera thread exiting\n", camera->config.name);
+                return NULL;
+            }
+        } else {
+            /* 开不起来（rc<0）：计数到第 2 次就升级成 USB 复位，见
+             * escalate_to_usb_reset。 */
+            camera->hard_failures++;
+            /* 复位也救不回来时，档位是剩下的嫌疑——可能在 STREAMON 阶段就
+             * 排不下这个等时档，那样流根本不会启动，停摆那条路永远等不到。 */
+            camera->open_failures_at_mode++;
+            if (camera->open_failures_at_mode ==
+                OPEN_FAILURES_BEFORE_ALTSETTING_DOWNGRADE) {
+                /* 和停摆那条路一样，计数要在降档之前抓下来：成功降档会把
+                 * 它清零，之后再读就打不出触发这次降级的次数。 */
+                unsigned failed = camera->open_failures_at_mode;
+                int previous_alt = camera->config.forced_altsetting;
+                if (maybe_downgrade_altsetting(camera)) {
+                    fprintf(stderr,
+                            "[%s] %u failed opens at alt=%d; dropping to "
+                            "alt=%d payload=%d\n",
+                            camera->config.name, failed, previous_alt,
+                            camera->config.forced_altsetting,
+                            camera->config.forced_payload);
+                } else {
+                    fprintf(stderr,
+                            "[%s] %u failed opens but alt=%d is already the "
+                            "lowest setting for this camera; staying put\n",
+                            camera->config.name, failed,
+                            camera->config.forced_altsetting);
+                }
+            }
+        }
+        if (!g_stop) {
+            sleep(1);
+        }
+    }
+    uvc_exit(context);
+    return NULL;
+}
+
+static void print_usage(const char *program) {
+    fprintf(stderr,
+            "usage: %s --config FILE [--validate-only] "
+            "[--parent-pid PID]\n",
+            program);
+}
+
+/* SIGTERM 之后必须退得掉。客户端（uvc_camera_service.py）只给 2 秒宽限：
+ * terminate() → 等 2 秒 → kill()。超了就是 SIGKILL，进程死在 libusb 调用
+ * 中间、设备停在激活的 alt setting 上，下一轮照样起不来——正是 2026-09-15
+ * 09:24 那次事故的形状。
+ *
+ * 光置 g_stop 不够：相机线程可能正陷在 uvc_open 的同步 libusb 调用里（卡死
+ * 的设备上它不返回），永远走不到循环头那个 g_stop 判断，pthread_join 于是
+ * 永远等下去。实测：生产二进制收到 SIGTERM 后 3 分钟不退，只攥着 DECXIN 的
+ * fd，left/right 都已干净释放，日志停在断流那一刻——连
+ * [SUPERVISION] parent exited 都没打出来。
+ *
+ * 所以 join 必须有界：整体 1.5 秒、单路 0.8 秒（健康时三路是并行收尾的，
+ * 实测全程 0.56 秒，留足余量）。超时就 detach、继续走，main 一返回进程即
+ * 结束——至少把能收的收干净了，跟客户端硬杀不是一回事。
+ *
+ * 注意 join 循环同时就是主运行循环，所以正常运行时不能套这个截止时间，
+ * 只能短超时轮询着等 g_stop（见 main 里那段说明）。 */
+#define SHUTDOWN_JOIN_TOTAL_MS 1500
+#define SHUTDOWN_JOIN_PER_CAMERA_MS 800
+#define SHUTDOWN_JOIN_POLL_MS 200
+
+/* 距 deadline 还有多少毫秒（≤0 表示已过期）。 */
+static long ms_until(const struct timespec *deadline) {
+    struct timespec now;
+    clock_gettime(CLOCK_REALTIME, &now);
+    return (long)(deadline->tv_sec - now.tv_sec) * 1000L +
+           (long)(deadline->tv_nsec - now.tv_nsec) / 1000000L;
+}
+
+/* 现在起 ms 毫秒之后的时刻。pthread_timedjoin_np 按 CLOCK_REALTIME 算。 */
+static struct timespec deadline_after_ms(long ms) {
+    struct timespec t;
+    clock_gettime(CLOCK_REALTIME, &t);
+    t.tv_sec += ms / 1000;
+    t.tv_nsec += (ms % 1000) * 1000000L;
+    if (t.tv_nsec >= 1000000000L) {
+        t.tv_sec += 1;
+        t.tv_nsec -= 1000000000L;
+    }
+    return t;
+}
+
+int main(int argc, char **argv) {
+    const char *config_path = NULL;
+    int validate_only = 0;
+    camera_config_t configs[MAX_CAMERAS];
+    camera_state_t cameras[MAX_CAMERAS];
+    size_t camera_count = 0;
+    size_t started = 0;
+    struct sigaction action;
+
+    for (int i = 1; i < argc; ++i) {
+        if (strcmp(argv[i], "--config") == 0 && i + 1 < argc) {
+            config_path = argv[++i];
+        } else if (strcmp(argv[i], "--validate-only") == 0) {
+            validate_only = 1;
+        } else if (strcmp(argv[i], "--parent-pid") == 0 &&
+                   i + 1 < argc) {
+            if (parse_int(argv[++i], &g_parent_pid) != 0 ||
+                g_parent_pid <= 1) {
+                fprintf(stderr, "invalid --parent-pid\n");
+                return 2;
+            }
+        } else {
+            print_usage(argv[0]);
+            return 2;
+        }
+    }
+    if (config_path == NULL || load_config(config_path, configs,
+                                           &camera_count) != 0) {
+        print_usage(argv[0]);
+        return 2;
+    }
+    if (validate_only) {
+        for (size_t i = 0; i < camera_count; ++i) {
+            fprintf(stdout,
+                    "valid[%zu] name=%s vidpid=%04x:%04x bus=%d port=%s "
+                    "interface=%d alt=%d payload=%d mode=%dx%d MJPEG@%d "
+                    "socket=%s\n",
+                    i, configs[i].name, configs[i].vid, configs[i].pid,
+                    configs[i].usb_bus, configs[i].usb_port_path,
+                    configs[i].streaming_interface,
+                    configs[i].forced_altsetting, configs[i].forced_payload,
+                    configs[i].width, configs[i].height, configs[i].fps,
+                    configs[i].socket_path);
+        }
+        return 0;
+    }
+    memset(&action, 0, sizeof(action));
+    action.sa_handler = request_stop;
+    sigemptyset(&action.sa_mask);
+    sigaction(SIGINT, &action, NULL);
+    sigaction(SIGTERM, &action, NULL);
+
+    memset(cameras, 0, sizeof(cameras));
+    for (size_t i = 0; i < camera_count; ++i) {
+        cameras[i].config = configs[i];
+        cameras[i].listen_fd = -1;
+        cameras[i].client_fd = -1;
+        pthread_mutex_init(&cameras[i].mutex, NULL);
+        pthread_cond_init(&cameras[i].condition, NULL);
+        if (pthread_create(&cameras[i].thread, NULL, camera_main,
+                           &cameras[i]) != 0) {
+            fprintf(stderr, "[%s] capture thread creation failed\n",
+                    cameras[i].config.name);
+            g_stop = 1;
+            break;
+        }
+        started++;
+    }
+    /* 这个 join 循环**就是服务的主运行循环**——它在启动时进入、一直跑到
+     * g_stop，不是「收尾时才走的一段」。所以截止时间不能在进循环前就算好
+     * （那样正常运行时也会到点超时、服务自己退出），要等 g_stop 真置位时
+     * 才开始计时。没置位时只用 200ms 短超时轮询，成本可忽略。 */
+    int shutdown_started = 0;
+    struct timespec shutdown_deadline = {0, 0};
+    for (size_t i = 0; i < started; ++i) {
+        int join_rc;
+        for (;;) {
+            long budget = SHUTDOWN_JOIN_POLL_MS;
+            if (g_stop) {
+                if (!shutdown_started) {
+                    shutdown_deadline =
+                        deadline_after_ms(SHUTDOWN_JOIN_TOTAL_MS);
+                    shutdown_started = 1;
+                }
+                long left = ms_until(&shutdown_deadline);
+                budget = left < SHUTDOWN_JOIN_PER_CAMERA_MS
+                             ? left : SHUTDOWN_JOIN_PER_CAMERA_MS;
+                /* 总预算已用尽：不再等，但还是要问一次——线程可能早就退了
+                 * （健康的那几路是并行收尾的），0 超时的 join 会立刻返回。 */
+                if (budget < 0) {
+                    budget = 0;
+                }
+            }
+            struct timespec limit = deadline_after_ms(budget);
+            join_rc = pthread_timedjoin_np(cameras[i].thread, NULL, &limit);
+            if (join_rc != ETIMEDOUT) {
+                break;
+            }
+            if (!g_stop) {
+                continue; /* 正常运行中的轮询到期，接着等 */
+            }
+            if (budget == 0) {
+                break; /* 预算已尽，放弃这一路 */
+            }
+        }
+        if (join_rc == ETIMEDOUT) {
+            /* 线程没在预算内退出——多半还陷在设备调用里。不能为它把整个
+             * 进程陪进去，否则客户端 2 秒宽限一到就是 SIGKILL、设备留脏。
+             * detach 后 main 一返回进程即结束，内核会替我们释放设备句柄。
+             * 跳过下面的统计与销毁：那些结构线程可能还在用，销毁它们是
+             * use-after-free。 */
+            fprintf(stderr,
+                    "[%s] 收尾超时：线程未在预算内退出（多半卡在设备调用里），"
+                    "不再等它\n", cameras[i].config.name);
+            pthread_detach(cameras[i].thread);
+            continue;
+        }
+        pthread_mutex_lock(&cameras[i].mutex);
+        fprintf(stderr, "[%s] received=%llu output=%llu dropped=%llu "
+                "bad_jpeg=%llu bad_replaced=%llu write_errors=%llu "
+                "retries=%llu stalls=%llu usb_resets=%u\n",
+                cameras[i].config.name,
+                (unsigned long long)cameras[i].frames_received,
+                (unsigned long long)cameras[i].frames_output,
+                (unsigned long long)cameras[i].frames_dropped,
+                (unsigned long long)cameras[i].bad_jpeg_frames,
+                (unsigned long long)cameras[i].bad_jpeg_replaced,
+                (unsigned long long)cameras[i].write_errors,
+                (unsigned long long)cameras[i].reconnects,
+                (unsigned long long)cameras[i].stalls,
+                cameras[i].usb_resets);
+        pthread_mutex_unlock(&cameras[i].mutex);
+        pthread_cond_destroy(&cameras[i].condition);
+        pthread_mutex_destroy(&cameras[i].mutex);
+    }
+    return started == camera_count ? 0 : 1;
+}

collector/core/gripper/camera_service_src/tests/test_altsetting_ladder.c

@@ -0,0 +1,202 @@
+/* Deterministic tests for the altsetting ladder. No USB devices involved.
+ *
+ * The ladder is the thing that lets one binary work both on controllers that
+ * can carry DECXIN's high-bandwidth isochronous setting and on those that
+ * cannot, so its two failure modes are worth pinning down:
+ *
+ *   - silently accepting a pair the camera cannot do. alt and payload are one
+ *     unit (alt7's endpoint *is* 1280 B/packet); pairing 7 with 944 is exactly
+ *     the configuration that took the whole gripper down on 2026-09-15 with
+ *     "unsupported DECXIN mode" -> rc=2.
+ *   - silently refusing to step down, which leaves the camera wedged at a
+ *     setting its controller cannot carry.
+ *   - stepping down once and then jamming, because the counter that triggered
+ *     the step is never cleared back below its threshold: the comparison is an
+ *     equality against the threshold, so a counter left standing on it never
+ *     fires again and every rung below the second is unreachable.
+ *
+ * The state-file name is also pinned, because uvc_camera_service.py has to
+ * derive the same key in Python to read the result back; the two are only kept
+ * in step by this assertion and its Python counterpart.
+ */
+#undef NDEBUG
+#include <assert.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#define main camera_service_main
+#include "../src/camera_service.c"
+#undef main
+
+static camera_config_t make_camera(int vid, int pid, int width, int height) {
+    camera_config_t config;
+    set_defaults(&config);
+    snprintf(config.name, sizeof(config.name), "unit_1_test");
+    config.vid = vid;
+    config.pid = pid;
+    config.usb_bus = 1;
+    snprintf(config.usb_port_path, sizeof(config.usb_port_path), "2.2.2");
+    config.width = width;
+    config.height = height;
+    config.fps = 30;
+    snprintf(config.format, sizeof(config.format), "MJPEG");
+    snprintf(config.socket_path, sizeof(config.socket_path), "/tmp/x.sock");
+    snprintf(config.usb_serial, sizeof(config.usb_serial), "DECXIN-01");
+    snprintf(config.usb_controller, sizeof(config.usb_controller),
+             "0000:74:00.4");
+    return config;
+}
+
+static camera_config_t make_decxin(void) {
+    camera_config_t config = make_camera(0x1bcf, 0x2d4f, 1280, 960);
+    config.forced_altsetting = 7;
+    config.forced_payload = 1280;
+    return config;
+}
+
+static void test_accepts_every_rung_and_nothing_else(void) {
+    camera_config_t config = make_decxin();
+
+    assert(validate_config(&config, 0) == 0); /* alt7/1280, the preferred rung */
+    config.forced_altsetting = 6;
+    config.forced_payload = 944;
+    assert(validate_config(&config, 0) == 0); /* alt6/944, the fallback rung */
+
+    /* Alt and payload are a matched pair, so a mixed pair must be refused even
+     * though both numbers appear in the table on their own. */
+    config.forced_altsetting = 7;
+    config.forced_payload = 944;
+    assert(validate_config(&config, 0) == -1);
+    config.forced_altsetting = 6;
+    config.forced_payload = 1280;
+    assert(validate_config(&config, 0) == -1);
+    /* A pair nobody has measured must not be accepted on faith either. */
+    config.forced_altsetting = 5;
+    config.forced_payload = 800;
+    assert(validate_config(&config, 0) == -1);
+
+    config = make_camera(0x0c45, 0x636f, 640, 480);
+    config.forced_altsetting = 3;
+    config.forced_payload = 800;
+    assert(validate_config(&config, 0) == 0);
+    config.forced_altsetting = 4; /* the pre-2026-08-28 1600 B setting */
+    config.forced_payload = 1600;
+    assert(validate_config(&config, 0) == -1);
+}
+
+static void test_steps_down_one_rung_and_then_stops(void) {
+    camera_state_t camera;
+    memset(&camera, 0, sizeof(camera));
+    camera.config = make_decxin();
+
+    assert(mode_index_for(&camera.config) == 0);
+    /* Both counters are driven to non-zero first: stepping down has to clear
+     * *each* of them. The thresholds are tested with ==, so a counter left
+     * standing at the threshold never fires again and that whole trigger path
+     * gets one step and then jams -- the rungs below it might as well not
+     * exist. Stalls and failed opens are separate paths and each clears its
+     * own; a downgrade is a fresh start for both. */
+    camera.stalls_at_mode = 99;
+    camera.open_failures_at_mode = 99;
+    assert(maybe_downgrade_altsetting(&camera) == 1);
+    assert(camera.config.forced_altsetting == 6);
+    assert(camera.config.forced_payload == 944);
+    assert(mode_index_for(&camera.config) == 1);
+    assert(camera.stalls_at_mode == 0);
+    assert(camera.open_failures_at_mode == 0);
+
+    /* alt6 is the last rung: a further stall must not invent a worse one. */
+    assert(maybe_downgrade_altsetting(&camera) == 0);
+    assert(camera.config.forced_altsetting == 6);
+    assert(camera.config.forced_payload == 944);
+
+    /* Sightac has a single rung, so it never steps anywhere. */
+    camera.config = make_camera(0x0c45, 0x636f, 640, 480);
+    camera.config.forced_altsetting = 3;
+    camera.config.forced_payload = 800;
+    assert(maybe_downgrade_altsetting(&camera) == 0);
+    assert(camera.config.forced_altsetting == 3);
+
+    /* A pair that is in no table at all must not be walked off the end. */
+    camera.config = make_decxin();
+    camera.config.forced_payload = 944; /* 7/944: refused by validate_config */
+    assert(mode_index_for(&camera.config) == 2);
+    assert(maybe_downgrade_altsetting(&camera) == 0);
+}
+
+static void test_downgrade_is_remembered_under_a_stable_key(void) {
+    char parent[] = "/tmp/ksq-ladder-test-XXXXXX";
+    char state_dir[PATH_MAX];
+    char expected[PATH_MAX];
+    char contents[128];
+    camera_state_t camera;
+    FILE *file;
+    size_t read_bytes;
+
+    assert(mkdtemp(parent) != NULL);
+    /* A subdirectory that does not exist yet: persist_mode_choice creates it. */
+    snprintf(state_dir, sizeof(state_dir), "%s/camera_modes", parent);
+    memset(&camera, 0, sizeof(camera));
+    camera.config = make_decxin();
+    snprintf(camera.config.state_dir, sizeof(camera.config.state_dir), "%s",
+             state_dir);
+
+    assert(maybe_downgrade_altsetting(&camera) == 1);
+
+    /* Key = vid_pid_controller_serial with everything outside [A-Za-z0-9-]
+     * replaced by '_'. uvc_camera_service._mode_state_key must produce this
+     * exact string for the learned value to be read back. */
+    snprintf(expected, sizeof(expected), "%s/1bcf_2d4f_0000_74_00_4_DECXIN-01.mode",
+             state_dir);
+    file = fopen(expected, "r");
+    assert(file != NULL);
+    read_bytes = fread(contents, 1, sizeof(contents) - 1, file);
+    contents[read_bytes] = '\0';
+    fclose(file);
+    assert(strcmp(contents, "altsetting=6\npayload=944\n") == 0);
+
+    /* No temp file may be left behind next to the result. */
+    {
+        DIR *dir = opendir(state_dir);
+        struct dirent *entry;
+        int seen = 0;
+        assert(dir != NULL);
+        while ((entry = readdir(dir)) != NULL) {
+            if (entry->d_name[0] == '.') {
+                continue;
+            }
+            ++seen;
+            assert(strstr(entry->d_name, ".tmp.") == NULL);
+        }
+        closedir(dir);
+        assert(seen == 1);
+    }
+
+    unlink(expected);
+    rmdir(state_dir);
+    rmdir(parent);
+}
+
+static void test_missing_state_dir_is_not_fatal(void) {
+    camera_state_t camera;
+    memset(&camera, 0, sizeof(camera));
+    camera.config = make_decxin();
+    /* Empty state_dir means "do not remember anything" and must still step
+     * down in memory for the rest of this session. */
+    assert(camera.config.state_dir[0] == '\0');
+    assert(maybe_downgrade_altsetting(&camera) == 1);
+    assert(camera.config.forced_altsetting == 6);
+}
+
+int main(void) {
+    /* validate_config reports refusals on stderr; that is the production
+     * behaviour and is expected here, so keep the test output readable. */
+    freopen("/dev/null", "w", stderr);
+    test_accepts_every_rung_and_nothing_else();
+    test_steps_down_one_rung_and_then_stops();
+    test_downgrade_is_remembered_under_a_stable_key();
+    test_missing_state_dir_is_not_fatal();
+    printf("altsetting ladder: all assertions passed\n");
+    return 0;
+}

collector/core/gripper/camera_service_src/tests/test_frame_integrity.c

@@ -0,0 +1,45 @@
+/* Test the actual callback and queue without opening USB devices. */
+#undef NDEBUG
+#include <assert.h>
+#define main camera_service_main
+#include "../src/camera_service.c"
+#undef main
+
+int main(void) {
+    camera_state_t camera = {0};
+    uint8_t good[] = {0xff, 0xd8, 0x01, 0x02, 0xff, 0xd9};
+    uint8_t short_frame[] = {0xff};
+    uvc_frame_t frame = {0};
+    pthread_mutex_init(&camera.mutex, NULL);
+    pthread_cond_init(&camera.condition, NULL);
+    frame.frame_format = UVC_FRAME_FORMAT_MJPEG;
+    frame.data = good;
+    frame.data_bytes = sizeof(good);
+    frame.sequence = 1;
+    frame.capture_time_finished.tv_sec = 2;
+    enqueue_frame(&frame, &camera);
+    assert(camera.count == 1);
+    assert(camera.queue[0].sequence == 1);
+    assert(camera.queue[0].capture_timestamp_ns == 2000000000ull);
+    frame.data = short_frame;
+    frame.data_bytes = sizeof(short_frame);
+    frame.sequence = 2;
+    frame.capture_time_finished.tv_sec = 3;
+    enqueue_frame(&frame, &camera);
+    assert(camera.count == 1); /* No old image under a new timestamp. */
+    assert(camera.bad_jpeg_frames == 1);
+    assert(camera.frames_dropped == 1);
+    assert(camera.bad_jpeg_replaced == 0);
+    assert(camera.queue[0].capture_timestamp_ns == 2000000000ull);
+    frame.data = good;
+    frame.data_bytes = sizeof(good);
+    frame.sequence = 3;
+    enqueue_frame(&frame, &camera);
+    assert(camera.count == 2);
+    assert(camera.queue[1].sequence == 3);
+    assert(camera.queue[1].capture_timestamp_ns == 3000000000ull);
+    for (size_t i = 0; i < FRAME_QUEUE_DEPTH; ++i) free(camera.queue[i].data);
+    pthread_mutex_destroy(&camera.mutex);
+    pthread_cond_destroy(&camera.condition);
+    return 0;
+}

collector/core/gripper/camera_service_src/third_party/libuvc/CMakeLists.txt

@@ -0,0 +1,230 @@
+cmake_minimum_required(VERSION 3.1)
+project(libuvc
+  VERSION 0.0.7
+  LANGUAGES C
+)
+
+# Additional search scripts path for libusb-1.0, libjpeg, OpenCV
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/cmake)
+
+# Xcode and Visual Studio do not using CMAKE_BUILD_TYPE cache variable
+# so we use Release build type only with single configuration generators.
+if (NOT CMAKE_CONFIGURATION_TYPES)
+  if(NOT CMAKE_BUILD_TYPE)
+    message(STATUS "No build type selected, default to Release")
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" FORCE)
+  endif()
+endif()
+
+if(NOT CMAKE_BUILD_TARGET)
+    message(STATUS "No target type selected, default to both shared and static library")
+    set(CMAKE_BUILD_TARGET "Both" CACHE STRING "" FORCE)
+endif()
+
+option(BUILD_EXAMPLE "Build example program" ON)
+option(BUILD_TEST "Build test program" OFF)
+option(ENABLE_UVC_DEBUGGING "Enable UVC debugging" OFF)
+
+set(libuvc_DESCRIPTION "A cross-platform library for USB video devices")
+set(libuvc_URL "https://github.com/libuvc/libuvc")
+
+set(SOURCES 
+  src/ctrl.c
+  src/ctrl-gen.c
+  src/device.c
+  src/diag.c
+  src/frame.c
+  src/init.c
+  src/stream.c
+  src/misc.c
+)
+
+find_package(LibUSB)
+
+# JpegPkg name to differ from shipped with CMake
+find_package(JpegPkg QUIET)
+if(JPEG_FOUND)
+  message(STATUS "Building libuvc with JPEG support.")
+  set(LIBUVC_HAS_JPEG TRUE)
+  list(APPEND SOURCES src/frame-mjpeg.c)
+else()
+  message(WARNING "JPEG not found. libuvc will not support JPEG decoding.")
+endif()
+
+if((UNIX AND NOT APPLE) OR MINGW OR WIN32)
+  set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
+  set(THREADS_PREFER_PTHREAD_FLAG TRUE)
+  find_package(Threads REQUIRED)
+  set(threads Threads::Threads)
+endif()
+
+if(${CMAKE_BUILD_TARGET} MATCHES "Shared")
+  set(BUILD_UVC_SHARED TRUE)
+elseif(${CMAKE_BUILD_TARGET} MATCHES "Static")
+  set(BUILD_UVC_STATIC TRUE)
+elseif(${CMAKE_BUILD_TARGET} MATCHES "Both")
+  set(BUILD_UVC_SHARED TRUE)
+  set(BUILD_UVC_STATIC TRUE)
+else()
+  message(FATAL_ERROR "Invalid build type ${CMAKE_BUILD_TARGET}" )
+endif()
+
+if(BUILD_UVC_SHARED)
+  add_library(uvc SHARED ${SOURCES})
+  set_target_properties(uvc PROPERTIES
+    VERSION ${libuvc_VERSION}
+    SOVERSION ${libuvc_VERSION_MAJOR}
+    # Exported name of target within namespace LibUVC
+    EXPORT_NAME UVCShared
+  )
+  list(APPEND UVC_TARGETS uvc)
+  if(NOT LibUVC_STATIC)  
+    add_library(LibUVC::UVC ALIAS uvc)
+  endif()
+  # Aliases defined here available only if project included 
+  # via addsubdirectory
+  add_library(LibUVC::UVCShared ALIAS uvc)
+endif()
+
+if(BUILD_UVC_STATIC)
+  add_library(uvc_static STATIC ${SOURCES})
+  set_target_properties(uvc_static PROPERTIES
+    OUTPUT_NAME uvc
+    # Exported name of target within namespace LibUVC
+    EXPORT_NAME UVCStatic
+  )
+  list(APPEND UVC_TARGETS uvc_static)
+  add_library(LibUVC::UVCStatic ALIAS uvc_static)
+  if(LibUVC_STATIC)
+    add_library(LibUVC::UVC ALIAS uvc_static)
+  endif()
+endif()
+
+configure_file(include/libuvc/libuvc_config.h.in
+  include/libuvc/libuvc_config.h
+  @ONLY
+)
+
+foreach(target_name IN LISTS UVC_TARGETS)
+  target_include_directories(${target_name}
+    PUBLIC
+      # Different paths for includes for build and install phase supported 
+      # via INSTALL_INTERFACE and BUILD_INTERFACE generator expressions.
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+      $<INSTALL_INTERFACE:include>
+  )
+  target_link_libraries(${target_name}
+    # libusb-1.0 used internally so we link to it privately.
+    PRIVATE LibUSB::LibUSB ${threads}
+  )
+  if(JPEG_FOUND)
+    target_link_libraries(${target_name}
+      PRIVATE JPEG::JPEG
+    )
+  endif()
+  set_target_properties(${target_name} PROPERTIES
+      PUBLIC_HEADER "include/libuvc/libuvc.h;${CMAKE_CURRENT_BINARY_DIR}/include/libuvc/libuvc_config.h"
+  )
+  if(ENABLE_UVC_DEBUGGING)
+    target_compile_definitions(${target_name}
+      PRIVATE
+        UVC_DEBUGGING
+    )
+    find_library(
+            log-lib
+            log
+    )
+    target_link_libraries(
+            ${target_name}
+            PRIVATE
+            ${log-lib}
+    )
+  endif()
+endforeach()
+
+if(BUILD_EXAMPLE)
+  add_executable(example src/example.c)
+  find_package(Threads)
+  target_link_libraries(example
+    PRIVATE
+      LibUVC::UVC
+      Threads::Threads
+  )
+endif()
+
+if(BUILD_TEST)
+  # OpenCV defines targets with transitive dependencies not with namespaces but using opencv_ prefix. 
+  # This targets provide necessary include directories and linked flags.
+  find_package(OpenCVPkg REQUIRED
+    COMPONENTS
+      opencv_core
+      opencv_highgui
+  )
+
+  add_executable(uvc_test src/test.c)
+  target_link_libraries(uvc_test
+    PRIVATE
+      LibUVC::UVC
+      opencv_core
+      opencv_highgui
+  )
+endif()
+
+
+include(GNUInstallDirs)
+set(CMAKE_INSTALL_CMAKEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/libuvc)
+
+install(
+  TARGETS ${UVC_TARGETS}
+  EXPORT libuvcTargets
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+  PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/libuvc
+)
+
+install(EXPORT libuvcTargets
+  FILE libuvcTargets.cmake
+  NAMESPACE LibUVC::
+  DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+)
+
+install(FILES 
+    cmake/FindLibUSB.cmake
+    cmake/FindJpegPkg.cmake
+  DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+)
+
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(libuvcConfigVersion.cmake
+  COMPATIBILITY AnyNewerVersion
+)
+
+install(FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/libuvcConfigVersion.cmake
+  DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+)
+
+if(JPEG_FOUND)
+  # If we have used JPEG library we need to 
+  # add linker flag for it in config file for pkgconfig
+  set(PKGCONFIG_JPEG_LDFLAG "-ljpeg")
+endif()
+
+configure_file(libuvc.pc.in
+  ${PROJECT_BINARY_DIR}/libuvc.pc
+  @ONLY
+)
+
+install(FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/libuvc.pc
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
+)
+
+install(FILES libuvcConfig.cmake
+  DESTINATION ${CMAKE_INSTALL_CMAKEDIR}
+)
+
+

collector/core/gripper/camera_service_src/third_party/libuvc/LICENSE.txt

@@ -0,0 +1,31 @@
+Software License Agreement (BSD License)
+
+Copyright (C) 2010-2015 Ken Tossell
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following
+   disclaimer in the documentation and/or other materials provided
+   with the distribution.
+ * Neither the name of the author nor other contributors may be
+   used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

collector/core/gripper/camera_service_src/third_party/libuvc/README.md

@@ -0,0 +1,29 @@
+`libuvc` is a cross-platform library for USB video devices, built atop `libusb`.
+It enables fine-grained control over USB video devices exporting the standard USB Video Class
+(UVC) interface, enabling developers to write drivers for previously unsupported devices,
+or just access UVC devices in a generic fashion.
+
+## Getting and Building libuvc
+
+Prerequisites: You will need `libusb` and [CMake](http://www.cmake.org/) installed.
+
+To build, you can just run these shell commands:
+
+    git clone https://github.com/libuvc/libuvc
+    cd libuvc
+    mkdir build
+    cd build
+    cmake ..
+    make && sudo make install
+
+and you're set! If you want to change the build configuration, you can edit `CMakeCache.txt`
+in the build directory, or use a CMake GUI to make the desired changes.
+
+There is also `BUILD_EXAMPLE` and `BUILD_TEST` options to enable the compilation of `example` and `uvc_test` programs. To use them, replace the `cmake ..` command above with `cmake .. -DBUILD_TEST=ON -DBUILD_EXAMPLE=ON`.
+Then you can start them with `./example` and `./uvc_test` respectively. Note that you need OpenCV to build the later (for displaying image).
+
+## Developing with libuvc
+
+The documentation for `libuvc` can currently be found at https://libuvc.github.io/.
+
+Happy hacking!

collector/core/gripper/camera_service_src/third_party/libuvc/cameras/isight_imac.txt

@@ -0,0 +1,228 @@
+
+Bus 001 Device 007: ID 05ac:8501 Apple, Inc. Built-in iSight [Micron]
+Device Descriptor:
+  bLength                18
+  bDescriptorType         1
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  idVendor           0x05ac Apple, Inc.
+  idProduct          0x8501 Built-in iSight [Micron]
+  bcdDevice            1.89
+  iManufacturer           1 Micron
+  iProduct                2 Built-in iSight
+  iSerial                 0 
+  bNumConfigurations      1
+  Configuration Descriptor:
+    bLength                 9
+    bDescriptorType         2
+    wTotalLength          267
+    bNumInterfaces          2
+    bConfigurationValue     1
+    iConfiguration          0 
+    bmAttributes         0x80
+      (Bus Powered)
+    MaxPower              100mA
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         0
+      bInterfaceCount         2
+      bFunctionClass         14 Video
+      bFunctionSubClass       3 Video Interface Collection
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        0
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      1 Video Control
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoControl Interface Descriptor:
+        bLength                13
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdUVC               1.00
+        wTotalLength           49
+        dwClockFrequency       13.500000MHz
+        bInCollection           1
+        baInterfaceNr( 0)       1
+      VideoControl Interface Descriptor:
+        bLength                16
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Camera Sensor
+        bAssocTerminal          0
+        iTerminal               0 
+        wObjectiveFocalLengthMin      0
+        wObjectiveFocalLengthMax      0
+        wOcularFocalLength            0
+        bControlSize                  1
+        bmControls           0x00000000
+      VideoControl Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      5 (PROCESSING_UNIT)
+      Warning: Descriptor too short
+        bUnitID                 2
+        bSourceID               1
+        wMaxMultiplier          0
+        bControlSize            2
+        bmControls     0x00000039
+          Brightness
+          Saturation
+          Sharpness
+          Gamma
+        iProcessing             0 
+        bmVideoStandards     0x 9
+          None
+          SECAM - 625/50
+      VideoControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               2
+        iTerminal               0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0008  1x 8 bytes
+        bInterval              10
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoStreaming Interface Descriptor:
+        bLength                            14
+        bDescriptorType                    36
+        bDescriptorSubtype                  1 (INPUT_HEADER)
+        bNumFormats                         1
+        wTotalLength                      155
+        bEndPointAddress                  130
+        bmInfo                              0
+        bTerminalLink                       3
+        bStillCaptureMethod                 0
+        bTriggerSupport                     0
+        bTriggerUsage                       0
+        bControlSize                        1
+        bmaControls( 0)                    27
+      VideoStreaming Interface Descriptor:
+        bLength                            27
+        bDescriptorType                    36
+        bDescriptorSubtype                  4 (FORMAT_UNCOMPRESSED)
+        bFormatIndex                        1
+        bNumFrameDescriptors                3
+        guidFormat                            {55595659-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1400  3x 1024 bytes
+        bInterval               1
+Device Qualifier (for other device speed):
+  bLength                10
+  bDescriptorType         6
+  bcdUSB               2.00
+  bDeviceClass           14 Video
+  bDeviceSubClass         2 Video Streaming
+  bDeviceProtocol         0 
+  bMaxPacketSize0         8
+  bNumConfigurations      1
+Device Status:     0x0000
+  (Bus Powered)

collector/core/gripper/camera_service_src/third_party/libuvc/cameras/isight_macbook.txt

@@ -0,0 +1,228 @@
+
+Bus 001 Device 010: ID 05ac:8501 Apple, Inc. Built-in iSight [Micron]
+Device Descriptor:
+  bLength                18
+  bDescriptorType         1
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  idVendor           0x05ac Apple, Inc.
+  idProduct          0x8501 Built-in iSight [Micron]
+  bcdDevice            1.89
+  iManufacturer           1 Micron
+  iProduct                2 Built-in iSight
+  iSerial                 0 
+  bNumConfigurations      1
+  Configuration Descriptor:
+    bLength                 9
+    bDescriptorType         2
+    wTotalLength          267
+    bNumInterfaces          2
+    bConfigurationValue     1
+    iConfiguration          0 
+    bmAttributes         0x80
+      (Bus Powered)
+    MaxPower              100mA
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         0
+      bInterfaceCount         2
+      bFunctionClass         14 Video
+      bFunctionSubClass       3 Video Interface Collection
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        0
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      1 Video Control
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoControl Interface Descriptor:
+        bLength                13
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdUVC               1.00
+        wTotalLength           49
+        dwClockFrequency       13.500000MHz
+        bInCollection           1
+        baInterfaceNr( 0)       1
+      VideoControl Interface Descriptor:
+        bLength                16
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Camera Sensor
+        bAssocTerminal          0
+        iTerminal               0 
+        wObjectiveFocalLengthMin      0
+        wObjectiveFocalLengthMax      0
+        wOcularFocalLength            0
+        bControlSize                  1
+        bmControls           0x00000000
+      VideoControl Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      5 (PROCESSING_UNIT)
+      Warning: Descriptor too short
+        bUnitID                 2
+        bSourceID               1
+        wMaxMultiplier          0
+        bControlSize            2
+        bmControls     0x00000039
+          Brightness
+          Saturation
+          Sharpness
+          Gamma
+        iProcessing             0 
+        bmVideoStandards     0x 9
+          None
+          SECAM - 625/50
+      VideoControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               2
+        iTerminal               0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0008  1x 8 bytes
+        bInterval              10
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoStreaming Interface Descriptor:
+        bLength                            14
+        bDescriptorType                    36
+        bDescriptorSubtype                  1 (INPUT_HEADER)
+        bNumFormats                         1
+        wTotalLength                      155
+        bEndPointAddress                  130
+        bmInfo                              0
+        bTerminalLink                       3
+        bStillCaptureMethod                 0
+        bTriggerSupport                     0
+        bTriggerUsage                       0
+        bControlSize                        1
+        bmaControls( 0)                    27
+      VideoStreaming Interface Descriptor:
+        bLength                            27
+        bDescriptorType                    36
+        bDescriptorSubtype                  4 (FORMAT_UNCOMPRESSED)
+        bFormatIndex                        1
+        bNumFrameDescriptors                3
+        guidFormat                            {55595659-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                383976960
+        dwMaxBitRate                383976960
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  0
+        dwMinFrameInterval             333333
+        dwMaxFrameInterval             333333
+        dwFrameIntervalStep                 0
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1400  3x 1024 bytes
+        bInterval               1
+Device Qualifier (for other device speed):
+  bLength                10
+  bDescriptorType         6
+  bcdUSB               2.00
+  bDeviceClass           14 Video
+  bDeviceSubClass         2 Video Streaming
+  bDeviceProtocol         0 
+  bMaxPacketSize0         8
+  bNumConfigurations      1
+Device Status:     0x0000
+  (Bus Powered)

collector/core/gripper/camera_service_src/third_party/libuvc/cameras/logitech_hd_pro_920.txt

@@ -0,0 +1,1817 @@
+
+Bus 001 Device 018: ID 046d:082d Logitech, Inc. HD Pro Webcam C920
+Device Descriptor:
+  bLength                18
+  bDescriptorType         1
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  idVendor           0x046d Logitech, Inc.
+  idProduct          0x082d HD Pro Webcam C920
+  bcdDevice            0.11
+  iManufacturer           0 
+  iProduct                2 HD Pro Webcam C920
+  iSerial                 1 E1CA2A7F
+  bNumConfigurations      1
+  Configuration Descriptor:
+    bLength                 9
+    bDescriptorType         2
+    wTotalLength         3452
+    bNumInterfaces          4
+    bConfigurationValue     1
+    iConfiguration          0 
+    bmAttributes         0x80
+      (Bus Powered)
+    MaxPower              500mA
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         0
+      bInterfaceCount         2
+      bFunctionClass         14 Video
+      bFunctionSubClass       3 Video Interface Collection
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        0
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      1 Video Control
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoControl Interface Descriptor:
+        bLength                13
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdUVC               1.00
+        wTotalLength          214
+        dwClockFrequency      300.000000MHz
+        bInCollection           1
+        baInterfaceNr( 0)       1
+      VideoControl Interface Descriptor:
+        bLength                18
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Camera Sensor
+        bAssocTerminal          0
+        iTerminal               0 
+        wObjectiveFocalLengthMin      0
+        wObjectiveFocalLengthMax      0
+        wOcularFocalLength            0
+        bControlSize                  3
+        bmControls           0x00020a2e
+          Auto-Exposure Mode
+          Auto-Exposure Priority
+          Exposure Time (Absolute)
+          Focus (Absolute)
+          Zoom (Absolute)
+          PanTilt (Absolute)
+          Focus, Auto
+      VideoControl Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      5 (PROCESSING_UNIT)
+      Warning: Descriptor too short
+        bUnitID                 3
+        bSourceID               1
+        wMaxMultiplier      16384
+        bControlSize            2
+        bmControls     0x0000175b
+          Brightness
+          Contrast
+          Saturation
+          Sharpness
+          White Balance Temperature
+          Backlight Compensation
+          Gain
+          Power Line Frequency
+          White Balance Temperature, Auto
+        iProcessing             0 
+        bmVideoStandards     0x1b
+          None
+          NTSC - 525/60
+          SECAM - 625/50
+          NTSC - 625/50
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 6
+        guidExtensionCode         {d09ee423-7811-314f-ae52-d2fb8a8d3b48}
+        bNumControl            10
+        bNrPins                 1
+        baSourceID( 0)          3
+        bControlSize            2
+        bmControls( 0)       0xff
+        bmControls( 1)       0x03
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 8
+        guidExtensionCode         {e48e6769-0f41-db40-a850-7420d7d8240e}
+        bNumControl             7
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            2
+        bmControls( 0)       0x3b
+        bmControls( 1)       0x03
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 9
+        guidExtensionCode         {a94c5d1f-11de-8744-840d-50933c8ec8d1}
+        bNumControl            17
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            3
+        bmControls( 0)       0xf3
+        bmControls( 1)       0xff
+        bmControls( 2)       0x23
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                10
+        guidExtensionCode         {1502e449-34f4-fe47-b158-0e885023e51b}
+        bNumControl             7
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            2
+        bmControls( 0)       0xaa
+        bmControls( 1)       0x07
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                11
+        guidExtensionCode         {212de5ff-3080-2c4e-82d9-f587d00540bd}
+        bNumControl             2
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            2
+        bmControls( 0)       0x00
+        bmControls( 1)       0x41
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                12
+        guidExtensionCode         {41769ea2-04de-e347-8b2b-f4341aff003b}
+        bNumControl            11
+        bNrPins                 1
+        baSourceID( 0)          3
+        bControlSize            2
+        bmControls( 0)       0x07
+        bmControls( 1)       0x7f
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             4
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               3
+        iTerminal               0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x83  EP 3 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0040  1x 64 bytes
+        bInterval               8
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoStreaming Interface Descriptor:
+        bLength                            16
+        bDescriptorType                    36
+        bDescriptorSubtype                  1 (INPUT_HEADER)
+        bNumFormats                         3
+        wTotalLength                     2822
+        bEndPointAddress                  129
+        bmInfo                              0
+        bTerminalLink                       4
+        bStillCaptureMethod                 0
+        bTriggerSupport                     0
+        bTriggerUsage                       0
+        bControlSize                        1
+        bmaControls( 0)                    27
+        bmaControls( 1)                    27
+        bmaControls( 2)                    27
+      VideoStreaming Interface Descriptor:
+        bLength                            27
+        bDescriptorType                    36
+        bDescriptorSubtype                  4 (FORMAT_UNCOMPRESSED)
+        bFormatIndex                        1
+        bNumFrameDescriptors               19
+        guidFormat                            {59555932-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 2 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                 24576000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                            90
+        dwMinBitRate                  1152000
+        dwMaxBitRate                  6912000
+        dwMaxVideoFrameBufferSize       28800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                  1536000
+        dwMaxBitRate                  9216000
+        dwMaxVideoFrameBufferSize       38400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                  2027520
+        dwMaxBitRate                 12165120
+        dwMaxVideoFrameBufferSize       50688
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           180
+        dwMinBitRate                  4608000
+        dwMaxBitRate                 27648000
+        dwMaxVideoFrameBufferSize      115200
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                  6144000
+        dwMaxBitRate                 36864000
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                  8110080
+        dwMaxBitRate                 48660480
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            432
+        wHeight                           240
+        dwMinBitRate                  8294400
+        dwMaxBitRate                 49766400
+        dwMaxVideoFrameBufferSize      207360
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           360
+        dwMinBitRate                 18432000
+        dwMaxBitRate                110592000
+        dwMaxVideoFrameBufferSize      460800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        10
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           448
+        dwMinBitRate                 28672000
+        dwMaxBitRate                172032000
+        dwMaxVideoFrameBufferSize      716800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        11
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                 38400000
+        dwMaxBitRate                184320000
+        dwMaxVideoFrameBufferSize      960000
+        dwDefaultFrameInterval         416666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            416666
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           1333333
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        12
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            864
+        wHeight                           480
+        dwMinBitRate                 33177600
+        dwMaxBitRate                159252480
+        dwMaxVideoFrameBufferSize      829440
+        dwDefaultFrameInterval         416666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            416666
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           1333333
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            42
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        13
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            960
+        wHeight                           720
+        dwMinBitRate                 55296000
+        dwMaxBitRate                165888000
+        dwMaxVideoFrameBufferSize     1382400
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  4
+        dwFrameInterval( 0)            666666
+        dwFrameInterval( 1)           1000000
+        dwFrameInterval( 2)           1333333
+        dwFrameInterval( 3)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            42
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        14
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1024
+        wHeight                           576
+        dwMinBitRate                 47185920
+        dwMaxBitRate                141557760
+        dwMaxVideoFrameBufferSize     1179648
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  4
+        dwFrameInterval( 0)            666666
+        dwFrameInterval( 1)           1000000
+        dwFrameInterval( 2)           1333333
+        dwFrameInterval( 3)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        15
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           720
+        dwMinBitRate                 73728000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize     1843200
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  3
+        dwFrameInterval( 0)           1000000
+        dwFrameInterval( 1)           1333333
+        dwFrameInterval( 2)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        16
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                           896
+        dwMinBitRate                114688000
+        dwMaxBitRate                172032000
+        dwMaxVideoFrameBufferSize     2867200
+        dwDefaultFrameInterval        1333333
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1333333
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        17
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1920
+        wHeight                          1080
+        dwMinBitRate                165888000
+        dwMaxBitRate                165888000
+        dwMaxVideoFrameBufferSize     4147200
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        18
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           2304
+        wHeight                          1296
+        dwMinBitRate                238878720
+        dwMaxBitRate                238878720
+        dwMaxVideoFrameBufferSize     5971968
+        dwDefaultFrameInterval        4999998
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           4999998
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        19
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           2304
+        wHeight                          1536
+        dwMinBitRate                283115520
+        dwMaxBitRate                283115520
+        dwMaxVideoFrameBufferSize     7077888
+        dwDefaultFrameInterval        4999998
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           4999998
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     1 (BT.709,sRGB)
+        bTransferCharacteristics            1 (BT.709)
+        bMatrixCoefficients                 4 (SMPTE 170M (BT.601))
+      VideoStreaming Interface Descriptor:
+        bLength                            28
+        bDescriptorType                    36
+        bDescriptorSubtype                 16 (FORMAT_FRAME_BASED)
+        bFormatIndex                        2
+        bNumFrameDescriptors               17
+        guidFormat                            {48323634-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 2 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+          bVariableSize                     1
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                 24576000
+        dwMaxBitRate                147456000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                            90
+        dwMinBitRate                  1152000
+        dwMaxBitRate                  6912000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                  1536000
+        dwMaxBitRate                  9216000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                  2027520
+        dwMaxBitRate                 12165120
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           180
+        dwMinBitRate                  4608000
+        dwMaxBitRate                 27648000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                  6144000
+        dwMaxBitRate                 36864000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                  8110080
+        dwMaxBitRate                 48660480
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            432
+        wHeight                           240
+        dwMinBitRate                  8294400
+        dwMaxBitRate                 49766400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           360
+        dwMinBitRate                 18432000
+        dwMaxBitRate                110592000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        10
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           448
+        dwMinBitRate                 28672000
+        dwMaxBitRate                172032000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        11
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                 38400000
+        dwMaxBitRate                230400000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        12
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            864
+        wHeight                           480
+        dwMinBitRate                 33177600
+        dwMaxBitRate                199065600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        13
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            960
+        wHeight                           720
+        dwMinBitRate                 55296000
+        dwMaxBitRate                331776000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        14
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1024
+        wHeight                           576
+        dwMinBitRate                 47185920
+        dwMaxBitRate                283115520
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        15
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           720
+        dwMinBitRate                 73728000
+        dwMaxBitRate                442368000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        16
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                           896
+        dwMinBitRate                114688000
+        dwMaxBitRate                688128000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                 17 (FRAME_FRAME_BASED)
+        bFrameIndex                        17
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1920
+        wHeight                          1080
+        dwMinBitRate                165888000
+        dwMaxBitRate                995328000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwBytesPerLine                      0
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     1 (BT.709,sRGB)
+        bTransferCharacteristics            1 (BT.709)
+        bMatrixCoefficients                 4 (SMPTE 170M (BT.601))
+      VideoStreaming Interface Descriptor:
+        bLength                            11
+        bDescriptorType                    36
+        bDescriptorSubtype                  6 (FORMAT_MJPEG)
+        bFormatIndex                        3
+        bNumFrameDescriptors               17
+        bFlags                              1
+          Fixed-size samples: Yes
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                 24576000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                            90
+        dwMinBitRate                  1152000
+        dwMaxBitRate                  6912000
+        dwMaxVideoFrameBufferSize       28800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                  1536000
+        dwMaxBitRate                  9216000
+        dwMaxVideoFrameBufferSize       38400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                  2027520
+        dwMaxBitRate                 12165120
+        dwMaxVideoFrameBufferSize       50688
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           180
+        dwMinBitRate                  4608000
+        dwMaxBitRate                 27648000
+        dwMaxVideoFrameBufferSize      115200
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                  6144000
+        dwMaxBitRate                 36864000
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                  8110080
+        dwMaxBitRate                 48660480
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            432
+        wHeight                           240
+        dwMinBitRate                  8294400
+        dwMaxBitRate                 49766400
+        dwMaxVideoFrameBufferSize      207360
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           360
+        dwMinBitRate                 18432000
+        dwMaxBitRate                110592000
+        dwMaxVideoFrameBufferSize      460800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        10
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           448
+        dwMinBitRate                 28672000
+        dwMaxBitRate                172032000
+        dwMaxVideoFrameBufferSize      716800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        11
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                 38400000
+        dwMaxBitRate                230400000
+        dwMaxVideoFrameBufferSize      960000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        12
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            864
+        wHeight                           480
+        dwMinBitRate                 33177600
+        dwMaxBitRate                199065600
+        dwMaxVideoFrameBufferSize      829440
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        13
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            960
+        wHeight                           720
+        dwMinBitRate                 55296000
+        dwMaxBitRate                331776000
+        dwMaxVideoFrameBufferSize     1382400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        14
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1024
+        wHeight                           576
+        dwMinBitRate                 47185920
+        dwMaxBitRate                283115520
+        dwMaxVideoFrameBufferSize     1179648
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        15
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           720
+        dwMinBitRate                 73728000
+        dwMaxBitRate                442368000
+        dwMaxVideoFrameBufferSize     1843200
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        16
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                           896
+        dwMinBitRate                114688000
+        dwMaxBitRate                688128000
+        dwMaxVideoFrameBufferSize     2867200
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            54
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        17
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1920
+        wHeight                          1080
+        dwMinBitRate                165888000
+        dwMaxBitRate                995328000
+        dwMaxVideoFrameBufferSize     4147200
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  7
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            416666
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           1333333
+        dwFrameInterval( 6)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     1 (BT.709,sRGB)
+        bTransferCharacteristics            1 (BT.709)
+        bMatrixCoefficients                 4 (SMPTE 170M (BT.601))
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x00c0  1x 192 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       2
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0180  1x 384 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       3
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0200  1x 512 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       4
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0280  1x 640 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       5
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0320  1x 800 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       6
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x03b0  1x 944 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       7
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0a80  2x 640 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       8
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0b20  2x 800 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       9
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0be0  2x 992 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting      10
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1380  3x 896 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting      11
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x13fc  3x 1020 bytes
+        bInterval               1
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         2
+      bInterfaceCount         2
+      bFunctionClass          1 Audio
+      bFunctionSubClass       2 Streaming
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        2
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      1 Control Device
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdADC               1.00
+        wTotalLength           38
+        bInCollection           1
+        baInterfaceNr( 0)       3
+      AudioControl Interface Descriptor:
+        bLength                12
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Microphone
+        bAssocTerminal          0
+        bNrChannels             1
+        wChannelConfig     0x0003
+          Left Front (L)
+          Right Front (R)
+        iChannelNames           0 
+        iTerminal               0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               5
+        iTerminal               0 
+      AudioControl Interface Descriptor:
+        bLength                 8
+        bDescriptorType        36
+        bDescriptorSubtype      6 (FEATURE_UNIT)
+        bUnitID                 5
+        bSourceID               1
+        bControlSize            1
+        bmaControls( 0)      0x03
+          Mute Control
+          Volume Control
+        iFeature                0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                255 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             2
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        16000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0044  1x 68 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       2
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                255 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             2
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        24000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0064  1x 100 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       3
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                255 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             2
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        32000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0084  1x 132 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+Device Qualifier (for other device speed):
+  bLength                10
+  bDescriptorType         6
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  bNumConfigurations      1
+Device Status:     0x0000
+  (Bus Powered)

collector/core/gripper/camera_service_src/third_party/libuvc/cameras/ms_lifecam_show.txt

@@ -0,0 +1,767 @@
+
+Bus 001 Device 010: ID 045e:0729 Microsoft Corp. 
+Device Descriptor:
+  bLength                18
+  bDescriptorType         1
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  idVendor           0x045e Microsoft Corp.
+  idProduct          0x0729 
+  bcdDevice            1.00
+  iManufacturer           1 Microsoft
+  iProduct                2 Microsoft� LifeCam Show(TM)
+  iSerial                 0 
+  bNumConfigurations      1
+  Configuration Descriptor:
+    bLength                 9
+    bDescriptorType         2
+    wTotalLength          961
+    bNumInterfaces          5
+    bConfigurationValue     1
+    iConfiguration          0 
+    bmAttributes         0x80
+      (Bus Powered)
+    MaxPower              320mA
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         0
+      bInterfaceCount         2
+      bFunctionClass         14 Video
+      bFunctionSubClass       3 Video Interface Collection
+      bFunctionProtocol       0 
+      iFunction               2 Microsoft� LifeCam Show(TM)
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        0
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      1 Video Control
+      bInterfaceProtocol      0 
+      iInterface              2 Microsoft� LifeCam Show(TM)
+      VideoControl Interface Descriptor:
+        bLength                13
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdUVC               1.00
+        wTotalLength           79
+        dwClockFrequency       24.000000MHz
+        bInCollection           1
+        baInterfaceNr( 0)       1
+      VideoControl Interface Descriptor:
+        bLength                18
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Camera Sensor
+        bAssocTerminal          0
+        iTerminal               0 
+        wObjectiveFocalLengthMin      0
+        wObjectiveFocalLengthMax      0
+        wOcularFocalLength            0
+        bControlSize                  3
+        bmControls           0x00000a0a
+          Auto-Exposure Mode
+          Exposure Time (Absolute)
+          Zoom (Absolute)
+          PanTilt (Absolute)
+      VideoControl Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      5 (PROCESSING_UNIT)
+      Warning: Descriptor too short
+        bUnitID                 2
+        bSourceID               1
+        wMaxMultiplier          0
+        bControlSize            2
+        bmControls     0x0000073b
+          Brightness
+          Contrast
+          Saturation
+          Sharpness
+          Gamma
+          Backlight Compensation
+          Gain
+          Power Line Frequency
+        iProcessing             0 
+        bmVideoStandards     0x 9
+          None
+          SECAM - 625/50
+      VideoControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               2
+        iTerminal               0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 4
+        guidExtensionCode         {5dc717a9-1941-da11-ae0e-000d56ac7b4c}
+        bNumControl             8
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            3
+        bmControls( 0)       0xf9
+        bmControls( 1)       0x01
+        bmControls( 2)       0xc0
+        iExtension              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x000a  1x 10 bytes
+        bInterval               5
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoStreaming Interface Descriptor:
+        bLength                            15
+        bDescriptorType                    36
+        bDescriptorSubtype                  1 (INPUT_HEADER)
+        bNumFormats                         2
+        wTotalLength                      587
+        bEndPointAddress                  130
+        bmInfo                              0
+        bTerminalLink                       3
+        bStillCaptureMethod                 2
+        bTriggerSupport                     1
+        bTriggerUsage                       1
+        bControlSize                        1
+        bmaControls( 0)                    27
+        bmaControls( 1)                    27
+      VideoStreaming Interface Descriptor:
+        bLength                            27
+        bDescriptorType                    36
+        bDescriptorSubtype                  4 (FORMAT_UNCOMPRESSED)
+        bFormatIndex                        1
+        bNumFrameDescriptors                6
+        guidFormat                            {59555932-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  3 (STILL_IMAGE_FRAME)
+        bEndpointAddress                    0
+        bNumImageSizePatterns               6
+        wWidth( 0)                        352
+        wHeight( 0)                       288
+        wWidth( 1)                        640
+        wHeight( 1)                       480
+        wWidth( 2)                        320
+        wHeight( 2)                       240
+        wWidth( 3)                        176
+        wHeight( 3)                       144
+        wWidth( 4)                        160
+        wHeight( 4)                       120
+        wWidth( 5)                        800
+        wHeight( 5)                       600
+        bNumCompressionPatterns             6
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     0 (Unspecified)
+        bTransferCharacteristics            0 (Unspecified)
+        bMatrixCoefficients                 0 (Unspecified)
+      VideoStreaming Interface Descriptor:
+        bLength                            11
+        bDescriptorType                    36
+        bDescriptorSubtype                  6 (FORMAT_MJPEG)
+        bFormatIndex                        2
+        bNumFrameDescriptors                9
+        bFlags                              1
+          Fixed-size samples: Yes
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval         666667
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)            666667
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1024
+        wHeight                           768
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval        1333333
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           1333333
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           960
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval        1333333
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           1333333
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                          1200
+        dwMinBitRate                196608000
+        dwMaxBitRate                196608000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval        1333333
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           1333333
+      VideoStreaming Interface Descriptor:
+        bLength                            42
+        bDescriptorType                    36
+        bDescriptorSubtype                  3 (STILL_IMAGE_FRAME)
+        bEndpointAddress                    0
+        bNumImageSizePatterns               9
+        wWidth( 0)                        352
+        wHeight( 0)                       288
+        wWidth( 1)                        640
+        wHeight( 1)                       480
+        wWidth( 2)                        320
+        wHeight( 2)                       240
+        wWidth( 3)                        176
+        wHeight( 3)                       144
+        wWidth( 4)                        160
+        wHeight( 4)                       120
+        wWidth( 5)                        800
+        wHeight( 5)                       600
+        wWidth( 6)                       1024
+        wHeight( 6)                       768
+        wWidth( 7)                       1280
+        wHeight( 7)                       960
+        wWidth( 8)                       1600
+        wHeight( 8)                      1200
+        bNumCompressionPatterns             9
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     0 (Unspecified)
+        bTransferCharacteristics            0 (Unspecified)
+        bMatrixCoefficients                 0 (Unspecified)
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0080  1x 128 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       2
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0200  1x 512 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       3
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0400  1x 1024 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       4
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0b00  2x 768 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       5
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0c00  2x 1024 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       6
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1380  3x 896 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       7
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x82  EP 2 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1400  3x 1024 bytes
+        bInterval               1
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         2
+      bInterfaceCount         2
+      bFunctionClass          1 Audio
+      bFunctionSubClass       2 Streaming
+      bFunctionProtocol       0 
+      iFunction               2 Microsoft� LifeCam Show(TM)
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        2
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      1 Control Device
+      bInterfaceProtocol      0 
+      iInterface              2 Microsoft� LifeCam Show(TM)
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdADC               1.00
+        wTotalLength           39
+        bInCollection           1
+        baInterfaceNr( 0)       3
+      AudioControl Interface Descriptor:
+        bLength                12
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Microphone
+        bAssocTerminal          0
+        bNrChannels             1
+        wChannelConfig     0x0000
+        iChannelNames           0 
+        iTerminal               0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      6 (FEATURE_UNIT)
+        bUnitID                 2
+        bSourceID               1
+        bControlSize            1
+        bmaControls( 0)      0x00
+        bmaControls( 1)      0x03
+          Mute
+          Volume
+        iFeature                0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          1
+        bSourceID               2
+        iTerminal               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                  1 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                14
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             1
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            2 Discrete
+        tSamFreq[ 0]        44100
+        tSamFreq[ 1]        48000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x83  EP 3 IN
+        bmAttributes            1
+          Transfer Type            Isochronous
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0062  1x 98 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        4
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass         3 Human Interface Device
+      bInterfaceSubClass      1 Boot Interface Subclass
+      bInterfaceProtocol      1 Keyboard
+      iInterface              0 
+        HID Device Descriptor:
+          bLength                 9
+          bDescriptorType        33
+          bcdHID               1.10
+          bCountryCode            0 Not supported
+          bNumDescriptors         1
+          bDescriptorType        34 Report
+          wDescriptorLength      24
+         Report Descriptors: 
+           ** UNAVAILABLE **
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x85  EP 5 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0001  1x 1 bytes
+        bInterval              10
+Device Qualifier (for other device speed):
+  bLength                10
+  bDescriptorType         6
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  bNumConfigurations      1
+Device Status:     0x0000
+  (Bus Powered)

collector/core/gripper/camera_service_src/third_party/libuvc/cameras/quickcampro9000.txt

@@ -0,0 +1,1543 @@
+
+Bus 001 Device 009: ID 046d:0809 Logitech, Inc. Webcam Pro 9000
+Device Descriptor:
+  bLength                18
+  bDescriptorType         1
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  idVendor           0x046d Logitech, Inc.
+  idProduct          0x0809 Webcam Pro 9000
+  bcdDevice            0.10
+  iManufacturer           0 
+  iProduct                0 
+  iSerial                 2 XXXXXXXX
+  bNumConfigurations      1
+  Configuration Descriptor:
+    bLength                 9
+    bDescriptorType         2
+    wTotalLength         2589
+    bNumInterfaces          4
+    bConfigurationValue     1
+    iConfiguration          0 
+    bmAttributes         0x80
+      (Bus Powered)
+    MaxPower              500mA
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         0
+      bInterfaceCount         2
+      bFunctionClass         14 Video
+      bFunctionSubClass       3 Video Interface Collection
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        0
+      bAlternateSetting       0
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      1 Video Control
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoControl Interface Descriptor:
+        bLength                13
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdUVC               1.00
+        wTotalLength          245
+        dwClockFrequency       48.000000MHz
+        bInCollection           1
+        baInterfaceNr( 0)       1
+      VideoControl Interface Descriptor:
+        bLength                18
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Camera Sensor
+        bAssocTerminal          0
+        iTerminal               0 
+        wObjectiveFocalLengthMin      0
+        wObjectiveFocalLengthMax      0
+        wOcularFocalLength            0
+        bControlSize                  3
+        bmControls           0x0000080e
+          Auto-Exposure Mode
+          Auto-Exposure Priority
+          Exposure Time (Absolute)
+          PanTilt (Absolute)
+      VideoControl Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      5 (PROCESSING_UNIT)
+      Warning: Descriptor too short
+        bUnitID                 2
+        bSourceID               1
+        wMaxMultiplier      16384
+        bControlSize            2
+        bmControls     0x0000175b
+          Brightness
+          Contrast
+          Saturation
+          Sharpness
+          White Balance Temperature
+          Backlight Compensation
+          Gain
+          Power Line Frequency
+          White Balance Temperature, Auto
+        iProcessing             0 
+        bmVideoStandards     0x1b
+          None
+          NTSC - 525/60
+          SECAM - 625/50
+          NTSC - 625/50
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 4
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d221e}
+        bNumControl            10
+        bNrPins                 1
+        baSourceID( 0)          2
+        bControlSize            2
+        bmControls( 0)       0xff
+        bmControls( 1)       0x03
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                27
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                13
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d221f}
+        bNumControl             7
+        bNrPins                 1
+        baSourceID( 0)          2
+        bControlSize            2
+        bmControls( 0)       0x6f
+        bmControls( 1)       0x01
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 8
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d2251}
+        bNumControl             3
+        bNrPins                 1
+        baSourceID( 0)          4
+        bControlSize            3
+        bmControls( 0)       0x19
+        bmControls( 1)       0x00
+        bmControls( 2)       0x00
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                10
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d2252}
+        bNumControl            24
+        bNrPins                 1
+        baSourceID( 0)          4
+        bControlSize            3
+        bmControls( 0)       0xff
+        bmControls( 1)       0xff
+        bmControls( 2)       0xff
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                14
+        guidExtensionCode         {b7935ba4-15c7-0245-90f4-532a3b311365}
+        bNumControl             4
+        bNrPins                 1
+        baSourceID( 0)          1
+        bControlSize            3
+        bmControls( 0)       0x0f
+        bmControls( 1)       0x00
+        bmControls( 2)       0x00
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                 9
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d2256}
+        bNumControl             5
+        bNrPins                 1
+        baSourceID( 0)          4
+        bControlSize            3
+        bmControls( 0)       0x0c
+        bmControls( 1)       0x00
+        bmControls( 2)       0x00
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                28
+        bDescriptorType        36
+        bDescriptorSubtype      6 (EXTENSION_UNIT)
+        bUnitID                12
+        guidExtensionCode         {82066163-7050-ab49-b8cc-b3855e8d2250}
+        bNumControl            17
+        bNrPins                 1
+        baSourceID( 0)          4
+        bControlSize            3
+        bmControls( 0)       0xfe
+        bmControls( 1)       0x7f
+        bmControls( 2)       0x70
+        iExtension              0 
+      VideoControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             5
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          0
+        bSourceID               4
+        iTerminal               0 
+      ** UNRECOGNIZED:  20 41 01 0b 82 06 61 63 70 50 ab 49 b8 cc b3 85 5e 8d 22 55 01 01 04 03 01 00 00 00 00 00 00 00
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x87  EP 7 IN
+        bmAttributes            3
+          Transfer Type            Interrupt
+          Synch Type               None
+          Usage Type               Data
+        wMaxPacketSize     0x0010  1x 16 bytes
+        bInterval               8
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      VideoStreaming Interface Descriptor:
+        bLength                            16
+        bDescriptorType                    36
+        bDescriptorSubtype                  1 (INPUT_HEADER)
+        bNumFormats                         3
+        wTotalLength                     1852
+        bEndPointAddress                  129
+        bmInfo                              0
+        bTerminalLink                       5
+        bStillCaptureMethod                 2
+        bTriggerSupport                     1
+        bTriggerUsage                       0
+        bControlSize                        1
+        bmaControls( 0)                    27
+        bmaControls( 1)                    27
+        bmaControls( 2)                    27
+      VideoStreaming Interface Descriptor:
+        bLength                            27
+        bDescriptorType                    36
+        bDescriptorSubtype                  4 (FORMAT_UNCOMPRESSED)
+        bFormatIndex                        1
+        bNumFrameDescriptors               18
+        guidFormat                            {59555932-0000-1000-8000-00aa00389b71}
+        bBitsPerPixel                      16
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                 24576000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                  1536000
+        dwMaxBitRate                  9216000
+        dwMaxVideoFrameBufferSize       38400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                  2027520
+        dwMaxBitRate                 12165120
+        dwMaxVideoFrameBufferSize       50688
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                  6144000
+        dwMaxBitRate                 36864000
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                  8110080
+        dwMaxBitRate                 48660480
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           360
+        dwMinBitRate                 18432000
+        dwMaxBitRate                110592000
+        dwMaxVideoFrameBufferSize      460800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           400
+        dwMinBitRate                 20480000
+        dwMaxBitRate                122880000
+        dwMaxVideoFrameBufferSize      512000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            768
+        wHeight                           480
+        dwMinBitRate                 29491200
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize      737280
+        dwDefaultFrameInterval         400000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           456
+        dwMinBitRate                 29184000
+        dwMaxBitRate                145920000
+        dwMaxVideoFrameBufferSize      729600
+        dwDefaultFrameInterval         400000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        10
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           504
+        dwMinBitRate                 32256000
+        dwMaxBitRate                161280000
+        dwMaxVideoFrameBufferSize      806400
+        dwDefaultFrameInterval         400000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        11
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                 38400000
+        dwMaxBitRate                192000000
+        dwMaxVideoFrameBufferSize      960000
+        dwDefaultFrameInterval         400000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        12
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            864
+        wHeight                           480
+        dwMinBitRate                 33177600
+        dwMaxBitRate                165888000
+        dwMaxVideoFrameBufferSize      829440
+        dwDefaultFrameInterval         400000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            38
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        13
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            960
+        wHeight                           720
+        dwMinBitRate                 55296000
+        dwMaxBitRate                165888000
+        dwMaxVideoFrameBufferSize     1382400
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  3
+        dwFrameInterval( 0)            666666
+        dwFrameInterval( 1)           1000000
+        dwFrameInterval( 2)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        14
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           720
+        dwMinBitRate                 73728000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize     1843200
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1333333
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        15
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           800
+        dwMinBitRate                 81920000
+        dwMaxBitRate                163840000
+        dwMaxVideoFrameBufferSize     2048000
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1333333
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        16
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                           904
+        dwMinBitRate                115712000
+        dwMaxBitRate                115712000
+        dwMaxVideoFrameBufferSize     2892800
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        17
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                          1000
+        dwMinBitRate                128000000
+        dwMaxBitRate                128000000
+        dwMaxVideoFrameBufferSize     3200000
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            30
+        bDescriptorType                    36
+        bDescriptorSubtype                  5 (FRAME_UNCOMPRESSED)
+        bFrameIndex                        18
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                          1200
+        dwMinBitRate                153600000
+        dwMaxBitRate                153600000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  1
+        dwFrameInterval( 0)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            79
+        bDescriptorType                    36
+        bDescriptorSubtype                  3 (STILL_IMAGE_FRAME)
+        bEndpointAddress                    0
+        bNumImageSizePatterns              18
+        wWidth( 0)                        640
+        wHeight( 0)                       480
+        wWidth( 1)                        160
+        wHeight( 1)                       120
+        wWidth( 2)                        176
+        wHeight( 2)                       144
+        wWidth( 3)                        320
+        wHeight( 3)                       240
+        wWidth( 4)                        352
+        wHeight( 4)                       288
+        wWidth( 5)                        640
+        wHeight( 5)                       360
+        wWidth( 6)                        640
+        wHeight( 6)                       400
+        wWidth( 7)                        768
+        wHeight( 7)                       480
+        wWidth( 8)                        800
+        wHeight( 8)                       456
+        wWidth( 9)                        800
+        wHeight( 9)                       504
+        wWidth(10)                        800
+        wHeight(10)                       600
+        wWidth(11)                        864
+        wHeight(11)                       480
+        wWidth(12)                        960
+        wHeight(12)                       720
+        wWidth(13)                       1280
+        wHeight(13)                       720
+        wWidth(14)                       1280
+        wHeight(14)                       800
+        wWidth(15)                       1600
+        wHeight(15)                       904
+        wWidth(16)                       1600
+        wHeight(16)                      1000
+        wWidth(17)                       1600
+        wHeight(17)                      1200
+        bNumCompressionPatterns            18
+        bCompression( 0)                    5
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     1 (BT.709,sRGB)
+        bTransferCharacteristics            1 (BT.709)
+        bMatrixCoefficients                 4 (SMPTE 170M (BT.601))
+      VideoStreaming Interface Descriptor:
+        bLength                            11
+        bDescriptorType                    36
+        bDescriptorSubtype                  6 (FORMAT_MJPEG)
+        bFormatIndex                        2
+        bNumFrameDescriptors               18
+        bFlags                              1
+          Fixed-size samples: Yes
+        bDefaultFrameIndex                  1
+        bAspectRatioX                       0
+        bAspectRatioY                       0
+        bmInterlaceFlags                 0x00
+          Interlaced stream or variable: No
+          Fields per frame: 1 fields
+          Field 1 first: No
+          Field pattern: Field 1 only
+          bCopyProtect                      0
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         1
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           480
+        dwMinBitRate                 24576000
+        dwMaxBitRate                147456000
+        dwMaxVideoFrameBufferSize      614400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         2
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            160
+        wHeight                           120
+        dwMinBitRate                  1536000
+        dwMaxBitRate                  9216000
+        dwMaxVideoFrameBufferSize       38400
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         3
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            176
+        wHeight                           144
+        dwMinBitRate                  2027520
+        dwMaxBitRate                 12165120
+        dwMaxVideoFrameBufferSize       50688
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         4
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            320
+        wHeight                           240
+        dwMinBitRate                  6144000
+        dwMaxBitRate                 36864000
+        dwMaxVideoFrameBufferSize      153600
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         5
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            352
+        wHeight                           288
+        dwMinBitRate                  8110080
+        dwMaxBitRate                 48660480
+        dwMaxVideoFrameBufferSize      202752
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         6
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           360
+        dwMinBitRate                 18432000
+        dwMaxBitRate                110592000
+        dwMaxVideoFrameBufferSize      460800
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         7
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            640
+        wHeight                           400
+        dwMinBitRate                 20480000
+        dwMaxBitRate                122880000
+        dwMaxVideoFrameBufferSize      512000
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         8
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            768
+        wHeight                           480
+        dwMinBitRate                 29491200
+        dwMaxBitRate                176947200
+        dwMaxVideoFrameBufferSize      737280
+        dwDefaultFrameInterval         333333
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                         9
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           456
+        dwMinBitRate                 29184000
+        dwMaxBitRate                175104000
+        dwMaxVideoFrameBufferSize      729600
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        10
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           504
+        dwMinBitRate                 32256000
+        dwMaxBitRate                193536000
+        dwMaxVideoFrameBufferSize      806400
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        11
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            800
+        wHeight                           600
+        dwMinBitRate                 38400000
+        dwMaxBitRate                230400000
+        dwMaxVideoFrameBufferSize      960000
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        12
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            864
+        wHeight                           480
+        dwMinBitRate                 33177600
+        dwMaxBitRate                199065600
+        dwMaxVideoFrameBufferSize      829440
+        dwDefaultFrameInterval         666666
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        13
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                            960
+        wHeight                           720
+        dwMinBitRate                 55296000
+        dwMaxBitRate                331776000
+        dwMaxVideoFrameBufferSize     1382400
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            50
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        14
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           720
+        dwMinBitRate                 73728000
+        dwMaxBitRate                442368000
+        dwMaxVideoFrameBufferSize     1843200
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  6
+        dwFrameInterval( 0)            333333
+        dwFrameInterval( 1)            400000
+        dwFrameInterval( 2)            500000
+        dwFrameInterval( 3)            666666
+        dwFrameInterval( 4)           1000000
+        dwFrameInterval( 5)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            46
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        15
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1280
+        wHeight                           800
+        dwMinBitRate                 81920000
+        dwMaxBitRate                409600000
+        dwMaxVideoFrameBufferSize     2048000
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  5
+        dwFrameInterval( 0)            400000
+        dwFrameInterval( 1)            500000
+        dwFrameInterval( 2)            666666
+        dwFrameInterval( 3)           1000000
+        dwFrameInterval( 4)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        16
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                           904
+        dwMinBitRate                115712000
+        dwMaxBitRate                231424000
+        dwMaxVideoFrameBufferSize     2892800
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1000000
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        17
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                          1000
+        dwMinBitRate                128000000
+        dwMaxBitRate                256000000
+        dwMaxVideoFrameBufferSize     3200000
+        dwDefaultFrameInterval        1000000
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1000000
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            34
+        bDescriptorType                    36
+        bDescriptorSubtype                  7 (FRAME_MJPEG)
+        bFrameIndex                        18
+        bmCapabilities                   0x00
+          Still image unsupported
+        wWidth                           1600
+        wHeight                          1200
+        dwMinBitRate                153600000
+        dwMaxBitRate                307200000
+        dwMaxVideoFrameBufferSize     3840000
+        dwDefaultFrameInterval        2000000
+        bFrameIntervalType                  2
+        dwFrameInterval( 0)           1000000
+        dwFrameInterval( 1)           2000000
+      VideoStreaming Interface Descriptor:
+        bLength                            83
+        bDescriptorType                    36
+        bDescriptorSubtype                  3 (STILL_IMAGE_FRAME)
+        bEndpointAddress                    0
+        bNumImageSizePatterns              18
+        wWidth( 0)                        640
+        wHeight( 0)                       480
+        wWidth( 1)                        160
+        wHeight( 1)                       120
+        wWidth( 2)                        176
+        wHeight( 2)                       144
+        wWidth( 3)                        320
+        wHeight( 3)                       240
+        wWidth( 4)                        352
+        wHeight( 4)                       288
+        wWidth( 5)                        640
+        wHeight( 5)                       360
+        wWidth( 6)                        640
+        wHeight( 6)                       400
+        wWidth( 7)                        768
+        wHeight( 7)                       480
+        wWidth( 8)                        800
+        wHeight( 8)                       456
+        wWidth( 9)                        800
+        wHeight( 9)                       504
+        wWidth(10)                        800
+        wHeight(10)                       600
+        wWidth(11)                        864
+        wHeight(11)                       480
+        wWidth(12)                        960
+        wHeight(12)                       720
+        wWidth(13)                       1280
+        wHeight(13)                       720
+        wWidth(14)                       1280
+        wHeight(14)                       800
+        wWidth(15)                       1600
+        wHeight(15)                       904
+        wWidth(16)                       1600
+        wHeight(16)                      1000
+        wWidth(17)                       1600
+        wHeight(17)                      1200
+        bNumCompressionPatterns            18
+        bCompression( 0)                    5
+        bCompression( 1)                   10
+        bCompression( 2)                   15
+        bCompression( 3)                   20
+        bCompression( 4)                   25
+      VideoStreaming Interface Descriptor:
+        bLength                             6
+        bDescriptorType                    36
+        bDescriptorSubtype                 13 (COLORFORMAT)
+        bColorPrimaries                     1 (BT.709,sRGB)
+        bTransferCharacteristics            1 (BT.709)
+        bMatrixCoefficients                 4 (SMPTE 170M (BT.601))
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x00c0  1x 192 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       2
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0180  1x 384 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       3
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0200  1x 512 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       4
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0280  1x 640 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       5
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0320  1x 800 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       6
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x03b0  1x 944 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       7
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0a80  2x 640 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       8
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0b20  2x 800 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting       9
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0be0  2x 992 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting      10
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x1380  3x 896 bytes
+        bInterval               1
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        1
+      bAlternateSetting      11
+      bNumEndpoints           1
+      bInterfaceClass        14 Video
+      bInterfaceSubClass      2 Video Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      Endpoint Descriptor:
+        bLength                 7
+        bDescriptorType         5
+        bEndpointAddress     0x81  EP 1 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x13fc  3x 1020 bytes
+        bInterval               1
+    Interface Association:
+      bLength                 8
+      bDescriptorType        11
+      bFirstInterface         2
+      bInterfaceCount         2
+      bFunctionClass          1 Audio
+      bFunctionSubClass       2 Streaming
+      bFunctionProtocol       0 
+      iFunction               0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        2
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      1 Control Device
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      1 (HEADER)
+        bcdADC               1.00
+        wTotalLength           38
+        bInCollection           1
+        baInterfaceNr( 0)       3
+      AudioControl Interface Descriptor:
+        bLength                12
+        bDescriptorType        36
+        bDescriptorSubtype      2 (INPUT_TERMINAL)
+        bTerminalID             1
+        wTerminalType      0x0201 Microphone
+        bAssocTerminal          0
+        bNrChannels             1
+        wChannelConfig     0x0000
+        iChannelNames           0 
+        iTerminal               0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      3 (OUTPUT_TERMINAL)
+        bTerminalID             3
+        wTerminalType      0x0101 USB Streaming
+        bAssocTerminal          1
+        bSourceID               5
+        iTerminal               0 
+      AudioControl Interface Descriptor:
+        bLength                 9
+        bDescriptorType        36
+        bDescriptorSubtype      6 (FEATURE_UNIT)
+        bUnitID                 5
+        bSourceID               1
+        bControlSize            1
+        bmaControls( 0)      0x03
+          Mute
+          Volume
+        bmaControls( 1)      0x00
+        iFeature                0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       0
+      bNumEndpoints           0
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       1
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                  1 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             1
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        16000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x86  EP 6 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0044  1x 68 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       2
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                  1 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             1
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        24000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x86  EP 6 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0064  1x 100 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       3
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                  1 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             1
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        32000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x86  EP 6 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x0084  1x 132 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+    Interface Descriptor:
+      bLength                 9
+      bDescriptorType         4
+      bInterfaceNumber        3
+      bAlternateSetting       4
+      bNumEndpoints           1
+      bInterfaceClass         1 Audio
+      bInterfaceSubClass      2 Streaming
+      bInterfaceProtocol      0 
+      iInterface              0 
+      AudioStreaming Interface Descriptor:
+        bLength                 7
+        bDescriptorType        36
+        bDescriptorSubtype      1 (AS_GENERAL)
+        bTerminalLink           3
+        bDelay                  1 frames
+        wFormatTag              1 PCM
+      AudioStreaming Interface Descriptor:
+        bLength                11
+        bDescriptorType        36
+        bDescriptorSubtype      2 (FORMAT_TYPE)
+        bFormatType             1 (FORMAT_TYPE_I)
+        bNrChannels             1
+        bSubframeSize           2
+        bBitResolution         16
+        bSamFreqType            1 Discrete
+        tSamFreq[ 0]        48000
+      Endpoint Descriptor:
+        bLength                 9
+        bDescriptorType         5
+        bEndpointAddress     0x86  EP 6 IN
+        bmAttributes            5
+          Transfer Type            Isochronous
+          Synch Type               Asynchronous
+          Usage Type               Data
+        wMaxPacketSize     0x00c4  1x 196 bytes
+        bInterval               4
+        bRefresh                0
+        bSynchAddress           0
+        AudioControl Endpoint Descriptor:
+          bLength                 7
+          bDescriptorType        37
+          bDescriptorSubtype      1 (EP_GENERAL)
+          bmAttributes         0x01
+            Sampling Frequency
+          bLockDelayUnits         0 Undefined
+          wLockDelay              0 Undefined
+Device Qualifier (for other device speed):
+  bLength                10
+  bDescriptorType         6
+  bcdUSB               2.00
+  bDeviceClass          239 Miscellaneous Device
+  bDeviceSubClass         2 ?
+  bDeviceProtocol         1 Interface Association
+  bMaxPacketSize0        64
+  bNumConfigurations      1
+Device Status:     0x0000
+  (Bus Powered)

collector/core/gripper/camera_service_src/third_party/libuvc/cameras/quickcampro9000_builtin_ctrls.txt

@@ -0,0 +1,13 @@
+Listing available controls for device video0:
+  Exposure, Auto Priority
+  Exposure (Absolute)
+  Exposure, Auto
+  Backlight Compensation
+  Sharpness
+  White Balance Temperature
+  Power Line Frequency
+  Gain
+  White Balance Temperature, Auto
+  Saturation
+  Contrast
+  Brightness

collector/core/gripper/camera_service_src/third_party/libuvc/cameras/quickcampro9000_extra_ctrls.txt

@@ -0,0 +1,18 @@
+Listing available controls for device video0:
+  Raw bits per pixel
+  Disable video processing
+  LED1 Frequency
+  LED1 Mode
+  Focus
+  Exposure, Auto Priority
+  Exposure (Absolute)
+  Exposure, Auto
+  Backlight Compensation
+  Sharpness
+  White Balance Temperature
+  Power Line Frequency
+  Gain
+  White Balance Temperature, Auto
+  Saturation
+  Contrast
+  Brightness

collector/core/gripper/camera_service_src/third_party/libuvc/changelog.txt

@@ -0,0 +1,140 @@
+Changes in 0.0.7 (2023-03-31)
+----------------
+
+New features:
+  - USB 3 support
+  - Several image/stream formats (incl. NV12, H264, BGR, RGB, P010)
+  - Format conversion functions
+  - Accept pre-opened libusb handles (used on Android)
+  - Library filename versioning (libuvc.0.0.7.dylib)
+  - Store system time upon receipt of new frame
+  - In-stream still-image-capture support
+  - Ensure successful stream parameter negotiation
+  - Improved build scripts
+  - Better logging on Android
+
+Bug fixes:
+  - Many build issues
+  - Log spam in production builds
+  - A situation where libuvc could hang during shutdown
+  - A deadlock in get_frame()
+  - An issue that could cause the first frame to fail
+  - Incorrect settings usage in example code
+  - Unnecessary device reopening
+  - Excessive number of transfer buffers affecting Mac builds
+  - Freeing of transfers that may still be in progress
+
+Changes in 0.0.6 (2017-09-21)
+----------------
+
+New features:
+  - Added support for pkg-config.
+    - Silence pkg-config when searching for libjpeg
+    - Resolve pkg-config conflict, update CONF_LIBRARY #11
+    - Actually use pkg-config to find libjpeg, and set cflags and ldflags for it. #78
+    - Add a pkg-config file to allow build systems to identify the flags needed for compiling and linking against this library  #77
+  - Add support for 16-bit greyscale image format (Y16) #77
+  - Add support for 8-bit raw colour formats, specifically: BA81, GRBG, GBRG, RGGB and BGGR #77
+  - Improve detection of The Imaging Source Cameras that implement the UVC protocols but don't announce themselves as UVC cameras (and ignore similar cameras that appear to be UVC but are not). #77
+  - add routine for listing frame configs #76
+  - New Travis configuration
+  - Add uvc_find_devices function to support libuvc_ros index selection #36
+  - VideoStreaming status processing #30
+  - Add conversion from YUYV to Y (GRAY8) and UV (GRAY8) #27
+  - Add LICENSE.txt.
+  - Add Dw_clock_frequency field and populate acording to UVC1.0 or 1.1 spec. #19
+  - Changes to enable compilation with Windows MSVC #13
+    - Modify ABS_FMT macro to function correctly with MSVC.
+    - Implement gettimeofday for MSVC.
+    - Use portable memset instead of bzero for MSVC compatibility.
+    - Annotate libusb callback methods with LIBUSB_CALL for MSVC.
+
+  - Merge of bulk mode transfer support from Tridge, Mauricio and James (#8)
+    - Support for BY8 frames
+    - (Very basic) support for UVC1.1 camera data structures
+    - Support for frame-based video streams
+    - Support for TIS astro CCD cameras
+    - Squashed a few possible bugs
+    - Added section descriptions and control getter/setter documentation
+
+Bug fixes:
+  - update CMakeLists.txt
+    - Add missing include (for ${CMAKE_INSTALL_LIBDIR}), fix static-/shared-only build #15
+    - Allow both static and dynamic versions of library to be built to work more neatly when building into runtime and development packages #77
+
+  - Update device.c, reduce salience of the alert which end user perceives as more important than it actually is. #79
+  - Clean up transfer buffers when an error occurs #77
+  - Fixed the issue that camera control functions can not work well with some cameras #41
+   UVC specification says that low byte of wIndex (for camera control) is interface number for camera control interface but current implementation of libuvc expects it is always zero and sometimes cause trouble.
+   Fixed camera control issue when using uvc_get_ctrl_len/uvc_get_ctrl/uvc_set_ctrl with camera that interface number of camera control interface is not zero.
+  - In some (as yet unidentified) circumstances it is possible for an interface to be claimed more than once.  This can cause an error. #77
+  - A race allows queued transfers to arrive and be viable for resubmission even when a stream is no longer running. #77
+  - Querying stream controls before claiming the interface can fail, so claim the interface first, then do the query. #77
+  - Show error code in error message to help debugging #77
+  - Add specific error messages for unsupported frame formats to make failures clearer #77
+ - Clean up compiler warnings #77
+ - Remove libusb.h from the public header #62
+ - Fix the first captured image being dropped #51
+   The first frame generated by any camera was always lost in the libuvc layer, and not passed on to the listening application.
+   The start value of seq (thus hold_seq) could be arbitrary, but it must be non-zero. Both the callback listener and the polling function's last_seq / last_polled_seq start initialised to zero, which causes any image with hold_seq zero to be ignored.
+ - Build fix for Chromium #48, #58
+   Some platforms use different version of libusb. For instance, Chromium compiles libusb by itself. So hard coding of libuse version (i.e. <libusb-1.0/libusb.h>) causes compile failure.
+   Remove libusb.h from the public header, This should fix the include path problems seen when including libuvc.h into other programs
+ - pthread_cond_timedwait nanoseconds shouldn't be greater than 1 billion #47
+    While using the library and testing the timed poll with 500000 us wait time, I noticed that it often happened that the timedwait returned EINVAL.
+According to http://stackoverflow.com/questions/11319063/pthread-cond-timedwait-root-causes-of-einval
+this might happen for several reasons, and one of them is when the number of nanoseconds in the timespec is greater than 1 billion (1 billion = 1 second).
+    Thus, I added a check that correctly updates the seconds and nanoseconds, bringing the nanosecond values in the range 0-999999999.
+    In Issue #16 it is mentioned that code sometimes crashes on uvc_stream_get_frame with some specific timeout values, this might have been the cause.
+     Fix for wrong setting of pthread_cond_timedwait nanoseconds
+  - Fix control functions for processors and other devices #32
+    When using a control function that is pertinent to a particular device (such as a processing device), the id of that device needs to be passed to the camera, or the call will fail
+  - Added docs for some more controls and switched to yaml doc file
+  - Updated documentation index
+  - Enable uvc_mjpeg2rgb function, if JPEG is supported
+
+Changes in 0.0.5 (2014-07-19)
+----------------
+
+New features:
+ - Added support for all of the camera terminal and processing unit controls, including the controls
+   that appeared in UVC 1.1 and 1.5.
+ - Added LIBUVC_VERSION_GTE(major, minor, patch) macro.
+
+Bug fixes:
+ - Switching to explicit kernel driver detachment since auto_detach isn't available in libusb < 1.0.16.
+ - The cmake module now looks for libuvc.dylib instead of libuvc.so on OS X.
+
+
+Changes in 0.0.4 (2014-06-26)
+----------------
+
+New features:
+ - Support devices with multiple streaming interfaces and multiple concurrent streams.
+   A new uvc_stream* API is added, along with a uvc_stream_handle type to encapsulate the
+   state of a single UVC stream. Multiple streams can run alongside each other, provided
+   your USB connection has enough bandwidth. Streams can be individually stopped and
+   resumed; the old uvc_start/stop_streaming API is still provided as a convenient way
+   to interact with the usual one-stream devices.
+ - Added support for MJPEG streams.
+ - Added functions for checking/setting autofocus mode.
+ - Added an interface to set/get arbitrary controls on units and terminals.
+ - Made the input, output, processing and extension units public.
+ - Implemented uvc_get_device and uvc_get_libusb_handle.
+ - Add a library-owned flag to uvc_frame_t so that users may allocate their own frame buffers.
+
+Bug fixes:
+ - Send frames as soon as they're received, not when the following frame arrives
+ - Fixed call to NULL when no status callback is provided.
+ - Fixed crash that occurred during shutdown if the USB device was disconnected during streaming.
+
+Miscellaneous improvements:
+ - Hid the transfer method (isochronous vs bulk) from the user. This was never really
+   selectable; the camera's streaming interface supports either bulk or isochronous
+   transfers, so now libuvc will figure out which one is appropriate. The `isochronous`
+   parameter has been converted to a `flags` parameter, which is currently unused but
+   could be used to convey up to 7 bits of stream mode information in the future.
+ - Improved the method for claiming the camera's interfaces.
+ - Renamed UVC_COLOR_FORMAT_* to UVC_FRAME_FORMAT_*. The old #defines are still available.
+ - Simplified format definition and lookup.
+ - Improved transfer status (error) handling.

collector/core/gripper/camera_service_src/third_party/libuvc/cmake/FindJpegPkg.cmake

@@ -0,0 +1,82 @@
+#[==============================================[
+FindJpegPkg
+-----------
+
+Searching jpeg library library and creating imported
+target JPEG::JPEG (this is different from shipped one with CMake)
+
+#]==============================================]
+
+# TODO Append parts for Version compasion and REQUIRED support
+if (MSVC OR MINGW)
+  return()
+endif()
+
+# Try to find JPEG using a module or pkg-config. If that doesn't work, search for the header.
+if (NOT TARGET JPEG::JPEG)
+  find_package(JPEG)
+  if (JPEG_FOUND)
+    message(STATUS "Found JPEG library using standard module")
+    set(IMPORTED_JPEG_INCLUDE_DIRS ${JPEG_INCLUDE_DIR})
+    set(IMPORTED_JPEG_LIBRARIES ${JPEG_LIBRARIES})
+  else()
+    find_package(PkgConfig)
+    pkg_check_modules(JPEG libjpeg)
+    if(JPEG_FOUND)
+      message(STATUS "JPEG found by pkgconfig")
+
+      if (DEFINED JPEG_INCLUDE_DIRS)
+        set(IMPORTED_JPEG_INCLUDE_DIRS ${JPEG_INCLUDE_DIRS})
+      endif()
+
+      if(JPEG_LIBRARIES)
+        find_library(JPEG_LIBRARY
+          NAMES ${JPEG_LIBRARIES}
+          PATHS ${JPEG_LIBDIR} ${JPEG_LIBRARY_DIRS}
+        )
+        if(JPEG_LIBRARY)
+          set(IMPORTED_JPEG_LIBRARIES ${JPEG_LIBRARY})
+        else()
+          message(WARNING "Could not found libjpeg library file")
+        endif()
+      endif()
+    else()
+      message(STATUS "Searching library manually")
+      find_path(IMPORTED_JPEG_INCLUDE_DIRS
+        NAMES jpeglib.h
+      )
+
+      if (NOT IMPORTED_JPEG_LIBRARIES)
+        find_library(IMPORTED_JPEG_LIBRARIES
+            NAMES jpeg
+        )
+      endif()
+    endif()
+  endif()
+
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(JPEG
+      REQUIRED_VARS IMPORTED_JPEG_LIBRARIES IMPORTED_JPEG_INCLUDE_DIRS
+  )
+
+  if(JPEG_FOUND)
+    set(JpegPkg_FOUND TRUE)
+    if (NOT TARGET JPEG::JPEG)
+      add_library(JPEG::JPEG
+        UNKNOWN IMPORTED
+      )
+      if(IMPORTED_JPEG_INCLUDE_DIRS)
+        set_target_properties(JPEG::JPEG PROPERTIES
+          INTERFACE_INCLUDE_DIRECTORIES ${IMPORTED_JPEG_INCLUDE_DIRS}
+        )
+      endif()
+      if(IMPORTED_JPEG_LIBRARIES)
+        set_target_properties(JPEG::JPEG PROPERTIES
+          IMPORTED_LINK_INTERFACE_LANGUAGES "C" 
+          IMPORTED_LOCATION ${IMPORTED_JPEG_LIBRARIES}
+        )
+      endif()
+    endif()
+  endif()
+
+endif()

collector/core/gripper/camera_service_src/third_party/libuvc/cmake/FindLibUSB.cmake

@@ -0,0 +1,51 @@
+#[==============================================[
+FindLibUSB
+-----------
+
+Searching libusb-1.0 library and creating imported 
+target LibUSB::LibUSB
+
+#]==============================================]
+
+# TODO Append parts for Version compasion and REQUIRED support
+
+if (MSVC OR MINGW)
+    return()
+endif()
+
+if (NOT TARGET LibUSB::LibUSB)
+  find_package(PkgConfig)
+  pkg_check_modules(LibUSB REQUIRED
+    libusb-1.0
+  )
+
+  if(LibUSB_FOUND)
+    message(STATUS "libusb-1.0 found using pkgconfig")
+
+    add_library(LibUSB::LibUSB
+      UNKNOWN IMPORTED
+    )
+    if (DEFINED LibUSB_INCLUDE_DIRS AND NOT LibUSB_INCLUDE_DIRS STREQUAL "")
+      set_target_properties(LibUSB::LibUSB PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES ${LibUSB_INCLUDE_DIRS}
+      )
+    endif()
+
+    if(LibUSB_LIBRARIES)
+      find_library(LibUSB_LIBRARY
+        NAMES ${LibUSB_LIBRARIES}
+        PATHS ${LibUSB_LIBDIR} ${LibUSB_LIBRARY_DIRS}
+      )
+      if(LibUSB_LIBRARY)
+        set_target_properties(LibUSB::LibUSB PROPERTIES
+          IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+          IMPORTED_LOCATION ${LibUSB_LIBRARY}
+        )
+      else()
+        message(WARNING "Could not found libusb-1.0 library file")
+      endif()
+    endif()
+  endif()
+else()
+  message(WARNING "libusb-1.0 could not be found using pkgconfig")
+endif()

collector/core/gripper/camera_service_src/third_party/libuvc/cmake/FindOpenCVPkg.cmake

@@ -0,0 +1,86 @@
+#[==============================================[
+FindOpenCVPkg
+-----------
+
+Searching OpenCV components on systems which does not have fully installed OpenCV. 
+Such systems does not include OpenCVConfig.cmake and OpenCVConfigVersion.cmake files.
+Example of such system is Ubuntu 18.04.
+This package try to use OpenCV config file first if it exists.
+
+#]==============================================]
+
+if (${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS)
+  set(comps ${${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS})
+else()
+  set(comps)
+endif()
+
+list(LENGTH comps comps_count)
+message(STATUS "Components requested: ${comps}")
+
+# Try to find components using standard OpenCV config package
+if(comps_count GREATER 0)
+  find_package(OpenCV QUIET
+    COMPONENTS ${comps}
+  )
+  if(OpenCV_FOUND)
+    set(OpenCVPkg_FOUND TRUE)
+    return()    
+  endif()
+else()
+  find_package(OpenCV QUIET)
+  if(OpenCV_FOUND)
+    set(OpenCVPkg_FOUND TRUE)
+    return()    
+  endif()
+endif()
+
+if(comps_count EQUAL 0)
+  set(err_level)
+  if(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED)
+    set(err_level FATAL_ERROR)
+  endif()
+  if (${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+    set(err_level STATUS)
+  endif()
+  message(${err_level} "Without standart OpenCV config file you must list components you want")
+  return()
+endif()
+
+unset(required_comps_not_found)
+foreach(comp IN LISTS comps)
+  string(REPLACE "opencv_" "" comp_name ${comp})
+  set(include_rel_path "opencv2/${comp_name}.hpp" "opencv2/${comp_name}/${comp_name}.hpp")
+  find_path(OpenCV_${comp}_INCLUDE_DIR
+    NAMES ${include_rel_path}
+  )
+  find_library(OpenCV_${comp}_LIBRARY
+    NAMES ${comp}
+  )
+  if (${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED_${comp} AND 
+      (NOT OpenCV_${comp}_INCLUDE_DIR OR NOT OpenCV_${comp}_LIBRARY))
+    list(APPEND required_comps_not_found ${comp})
+  else()
+    message(STATUS "Found component ${comp}: ${OpenCV_${comp}_LIBRARY}")
+  endif()
+endforeach()
+
+if(required_comps_not_found)
+  message(FATAL_ERROR "Following required components not found: ${required_comps_not_found}")
+  return()
+endif()
+
+foreach(comp IN LISTS comps)
+  if(NOT TARGET ${comp})
+    message(STATUS "No target ${comp} yet. Creating it")
+    add_library(${comp}
+      UNKNOWN IMPORTED
+    )
+    set_target_properties(${comp} PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES ${OpenCV_${comp}_INCLUDE_DIR}
+      IMPORTED_LOCATION ${OpenCV_${comp}_LIBRARY}
+    )
+  endif()
+endforeach()
+
+set(OpenCVPkg_FOUND TRUE)

collector/core/gripper/camera_service_src/third_party/libuvc/include/libuvc/libuvc.h

@@ -0,0 +1,833 @@
+#ifndef LIBUVC_H
+#define LIBUVC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h> // FILE
+#include <stdint.h>
+#include <sys/time.h>
+#include <libuvc/libuvc_config.h>
+
+struct libusb_context;
+struct libusb_device_handle;
+
+/** UVC error types, based on libusb errors
+ * @ingroup diag
+ */
+typedef enum uvc_error {
+  /** Success (no error) */
+  UVC_SUCCESS = 0,
+  /** Input/output error */
+  UVC_ERROR_IO = -1,
+  /** Invalid parameter */
+  UVC_ERROR_INVALID_PARAM = -2,
+  /** Access denied */
+  UVC_ERROR_ACCESS = -3,
+  /** No such device */
+  UVC_ERROR_NO_DEVICE = -4,
+  /** Entity not found */
+  UVC_ERROR_NOT_FOUND = -5,
+  /** Resource busy */
+  UVC_ERROR_BUSY = -6,
+  /** Operation timed out */
+  UVC_ERROR_TIMEOUT = -7,
+  /** Overflow */
+  UVC_ERROR_OVERFLOW = -8,
+  /** Pipe error */
+  UVC_ERROR_PIPE = -9,
+  /** System call interrupted */
+  UVC_ERROR_INTERRUPTED = -10,
+  /** Insufficient memory */
+  UVC_ERROR_NO_MEM = -11,
+  /** Operation not supported */
+  UVC_ERROR_NOT_SUPPORTED = -12,
+  /** Device is not UVC-compliant */
+  UVC_ERROR_INVALID_DEVICE = -50,
+  /** Mode not supported */
+  UVC_ERROR_INVALID_MODE = -51,
+  /** Resource has a callback (can't use polling and async) */
+  UVC_ERROR_CALLBACK_EXISTS = -52,
+  /** Undefined error */
+  UVC_ERROR_OTHER = -99
+} uvc_error_t;
+
+/** Color coding of stream, transport-independent
+ * @ingroup streaming
+ */
+enum uvc_frame_format {
+  UVC_FRAME_FORMAT_UNKNOWN = 0,
+  /** Any supported format */
+  UVC_FRAME_FORMAT_ANY = 0,
+  UVC_FRAME_FORMAT_UNCOMPRESSED,
+  UVC_FRAME_FORMAT_COMPRESSED,
+  /** YUYV/YUV2/YUV422: YUV encoding with one luminance value per pixel and
+   * one UV (chrominance) pair for every two pixels.
+   */
+  UVC_FRAME_FORMAT_YUYV,
+  UVC_FRAME_FORMAT_UYVY,
+  /** 24-bit RGB */
+  UVC_FRAME_FORMAT_RGB,
+  UVC_FRAME_FORMAT_BGR,
+  /** Motion-JPEG (or JPEG) encoded images */
+  UVC_FRAME_FORMAT_MJPEG,
+  UVC_FRAME_FORMAT_H264,
+  /** Greyscale images */
+  UVC_FRAME_FORMAT_GRAY8,
+  UVC_FRAME_FORMAT_GRAY16,
+  /* Raw colour mosaic images */
+  UVC_FRAME_FORMAT_BY8,
+  UVC_FRAME_FORMAT_BA81,
+  UVC_FRAME_FORMAT_SGRBG8,
+  UVC_FRAME_FORMAT_SGBRG8,
+  UVC_FRAME_FORMAT_SRGGB8,
+  UVC_FRAME_FORMAT_SBGGR8,
+  /** YUV420: NV12 */
+  UVC_FRAME_FORMAT_NV12,
+  /** YUV: P010 */
+  UVC_FRAME_FORMAT_P010,
+  /** Number of formats understood */
+  UVC_FRAME_FORMAT_COUNT,
+};
+
+/* UVC_COLOR_FORMAT_* have been replaced with UVC_FRAME_FORMAT_*. Please use
+ * UVC_FRAME_FORMAT_* instead of using these. */
+#define UVC_COLOR_FORMAT_UNKNOWN UVC_FRAME_FORMAT_UNKNOWN
+#define UVC_COLOR_FORMAT_UNCOMPRESSED UVC_FRAME_FORMAT_UNCOMPRESSED
+#define UVC_COLOR_FORMAT_COMPRESSED UVC_FRAME_FORMAT_COMPRESSED
+#define UVC_COLOR_FORMAT_YUYV UVC_FRAME_FORMAT_YUYV
+#define UVC_COLOR_FORMAT_UYVY UVC_FRAME_FORMAT_UYVY
+#define UVC_COLOR_FORMAT_RGB UVC_FRAME_FORMAT_RGB
+#define UVC_COLOR_FORMAT_BGR UVC_FRAME_FORMAT_BGR
+#define UVC_COLOR_FORMAT_MJPEG UVC_FRAME_FORMAT_MJPEG
+#define UVC_COLOR_FORMAT_GRAY8 UVC_FRAME_FORMAT_GRAY8
+#define UVC_COLOR_FORMAT_GRAY16 UVC_FRAME_FORMAT_GRAY16
+#define UVC_COLOR_FORMAT_NV12 UVC_FRAME_FORMAT_NV12
+
+/** VideoStreaming interface descriptor subtype (A.6) */
+enum uvc_vs_desc_subtype {
+  UVC_VS_UNDEFINED = 0x00,
+  UVC_VS_INPUT_HEADER = 0x01,
+  UVC_VS_OUTPUT_HEADER = 0x02,
+  UVC_VS_STILL_IMAGE_FRAME = 0x03,
+  UVC_VS_FORMAT_UNCOMPRESSED = 0x04,
+  UVC_VS_FRAME_UNCOMPRESSED = 0x05,
+  UVC_VS_FORMAT_MJPEG = 0x06,
+  UVC_VS_FRAME_MJPEG = 0x07,
+  UVC_VS_FORMAT_MPEG2TS = 0x0a,
+  UVC_VS_FORMAT_DV = 0x0c,
+  UVC_VS_COLORFORMAT = 0x0d,
+  UVC_VS_FORMAT_FRAME_BASED = 0x10,
+  UVC_VS_FRAME_FRAME_BASED = 0x11,
+  UVC_VS_FORMAT_STREAM_BASED = 0x12
+};
+
+struct uvc_format_desc;
+struct uvc_frame_desc;
+
+typedef struct uvc_still_frame_res {
+  struct uvc_still_frame_res *prev, *next;
+  uint8_t bResolutionIndex;
+  /** Image width */
+  uint16_t wWidth;
+  /** Image height */
+  uint16_t wHeight;
+} uvc_still_frame_res_t;
+
+typedef struct uvc_still_frame_desc {
+  struct uvc_format_desc *parent;
+  struct uvc_still_frame_desc *prev, *next;
+  /** Type of frame, such as JPEG frame or uncompressed frme */
+  enum uvc_vs_desc_subtype bDescriptorSubtype;
+  /** Index of the frame within the list of specs available for this format */
+  uint8_t bEndPointAddress;
+  uvc_still_frame_res_t* imageSizePatterns;
+  uint8_t bNumCompressionPattern;
+  /* indication of compression level, the higher, the more compression is applied to image */
+  uint8_t* bCompression;
+} uvc_still_frame_desc_t;
+
+/** Frame descriptor
+ *
+ * A "frame" is a configuration of a streaming format
+ * for a particular image size at one of possibly several
+ * available frame rates.
+ */
+typedef struct uvc_frame_desc {
+  struct uvc_format_desc *parent;
+  struct uvc_frame_desc *prev, *next;
+  /** Type of frame, such as JPEG frame or uncompressed frme */
+  enum uvc_vs_desc_subtype bDescriptorSubtype;
+  /** Index of the frame within the list of specs available for this format */
+  uint8_t bFrameIndex;
+  uint8_t bmCapabilities;
+  /** Image width */
+  uint16_t wWidth;
+  /** Image height */
+  uint16_t wHeight;
+  /** Bitrate of corresponding stream at minimal frame rate */
+  uint32_t dwMinBitRate;
+  /** Bitrate of corresponding stream at maximal frame rate */
+  uint32_t dwMaxBitRate;
+  /** Maximum number of bytes for a video frame */
+  uint32_t dwMaxVideoFrameBufferSize;
+  /** Default frame interval (in 100ns units) */
+  uint32_t dwDefaultFrameInterval;
+  /** Minimum frame interval for continuous mode (100ns units) */
+  uint32_t dwMinFrameInterval;
+  /** Maximum frame interval for continuous mode (100ns units) */
+  uint32_t dwMaxFrameInterval;
+  /** Granularity of frame interval range for continuous mode (100ns) */
+  uint32_t dwFrameIntervalStep;
+  /** Frame intervals */
+  uint8_t bFrameIntervalType;
+  /** number of bytes per line */
+  uint32_t dwBytesPerLine;
+  /** Available frame rates, zero-terminated (in 100ns units) */
+  uint32_t *intervals;
+} uvc_frame_desc_t;
+
+/** Format descriptor
+ *
+ * A "format" determines a stream's image type (e.g., raw YUYV or JPEG)
+ * and includes many "frame" configurations.
+ */
+typedef struct uvc_format_desc {
+  struct uvc_streaming_interface *parent;
+  struct uvc_format_desc *prev, *next;
+  /** Type of image stream, such as JPEG or uncompressed. */
+  enum uvc_vs_desc_subtype bDescriptorSubtype;
+  /** Identifier of this format within the VS interface's format list */
+  uint8_t bFormatIndex;
+  uint8_t bNumFrameDescriptors;
+  /** Format specifier */
+  union {
+    uint8_t guidFormat[16];
+    uint8_t fourccFormat[4];
+  };
+  /** Format-specific data */
+  union {
+    /** BPP for uncompressed stream */
+    uint8_t bBitsPerPixel;
+    /** Flags for JPEG stream */
+    uint8_t bmFlags;
+  };
+  /** Default {uvc_frame_desc} to choose given this format */
+  uint8_t bDefaultFrameIndex;
+  uint8_t bAspectRatioX;
+  uint8_t bAspectRatioY;
+  uint8_t bmInterlaceFlags;
+  uint8_t bCopyProtect;
+  uint8_t bVariableSize;
+  /** Available frame specifications for this format */
+  struct uvc_frame_desc *frame_descs;
+  struct uvc_still_frame_desc *still_frame_desc;
+} uvc_format_desc_t;
+
+/** UVC request code (A.8) */
+enum uvc_req_code {
+  UVC_RC_UNDEFINED = 0x00,
+  UVC_SET_CUR = 0x01,
+  UVC_GET_CUR = 0x81,
+  UVC_GET_MIN = 0x82,
+  UVC_GET_MAX = 0x83,
+  UVC_GET_RES = 0x84,
+  UVC_GET_LEN = 0x85,
+  UVC_GET_INFO = 0x86,
+  UVC_GET_DEF = 0x87
+};
+
+enum uvc_device_power_mode {
+  UVC_VC_VIDEO_POWER_MODE_FULL = 0x000b,
+  UVC_VC_VIDEO_POWER_MODE_DEVICE_DEPENDENT = 0x001b,
+};
+
+/** Camera terminal control selector (A.9.4) */
+enum uvc_ct_ctrl_selector {
+  UVC_CT_CONTROL_UNDEFINED = 0x00,
+  UVC_CT_SCANNING_MODE_CONTROL = 0x01,
+  UVC_CT_AE_MODE_CONTROL = 0x02,
+  UVC_CT_AE_PRIORITY_CONTROL = 0x03,
+  UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL = 0x04,
+  UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL = 0x05,
+  UVC_CT_FOCUS_ABSOLUTE_CONTROL = 0x06,
+  UVC_CT_FOCUS_RELATIVE_CONTROL = 0x07,
+  UVC_CT_FOCUS_AUTO_CONTROL = 0x08,
+  UVC_CT_IRIS_ABSOLUTE_CONTROL = 0x09,
+  UVC_CT_IRIS_RELATIVE_CONTROL = 0x0a,
+  UVC_CT_ZOOM_ABSOLUTE_CONTROL = 0x0b,
+  UVC_CT_ZOOM_RELATIVE_CONTROL = 0x0c,
+  UVC_CT_PANTILT_ABSOLUTE_CONTROL = 0x0d,
+  UVC_CT_PANTILT_RELATIVE_CONTROL = 0x0e,
+  UVC_CT_ROLL_ABSOLUTE_CONTROL = 0x0f,
+  UVC_CT_ROLL_RELATIVE_CONTROL = 0x10,
+  UVC_CT_PRIVACY_CONTROL = 0x11,
+  UVC_CT_FOCUS_SIMPLE_CONTROL = 0x12,
+  UVC_CT_DIGITAL_WINDOW_CONTROL = 0x13,
+  UVC_CT_REGION_OF_INTEREST_CONTROL = 0x14
+};
+
+/** Processing unit control selector (A.9.5) */
+enum uvc_pu_ctrl_selector {
+  UVC_PU_CONTROL_UNDEFINED = 0x00,
+  UVC_PU_BACKLIGHT_COMPENSATION_CONTROL = 0x01,
+  UVC_PU_BRIGHTNESS_CONTROL = 0x02,
+  UVC_PU_CONTRAST_CONTROL = 0x03,
+  UVC_PU_GAIN_CONTROL = 0x04,
+  UVC_PU_POWER_LINE_FREQUENCY_CONTROL = 0x05,
+  UVC_PU_HUE_CONTROL = 0x06,
+  UVC_PU_SATURATION_CONTROL = 0x07,
+  UVC_PU_SHARPNESS_CONTROL = 0x08,
+  UVC_PU_GAMMA_CONTROL = 0x09,
+  UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL = 0x0a,
+  UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL = 0x0b,
+  UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL = 0x0c,
+  UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL = 0x0d,
+  UVC_PU_DIGITAL_MULTIPLIER_CONTROL = 0x0e,
+  UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL = 0x0f,
+  UVC_PU_HUE_AUTO_CONTROL = 0x10,
+  UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL = 0x11,
+  UVC_PU_ANALOG_LOCK_STATUS_CONTROL = 0x12,
+  UVC_PU_CONTRAST_AUTO_CONTROL = 0x13
+};
+
+/** USB terminal type (B.1) */
+enum uvc_term_type {
+  UVC_TT_VENDOR_SPECIFIC = 0x0100,
+  UVC_TT_STREAMING = 0x0101
+};
+
+/** Input terminal type (B.2) */
+enum uvc_it_type {
+  UVC_ITT_VENDOR_SPECIFIC = 0x0200,
+  UVC_ITT_CAMERA = 0x0201,
+  UVC_ITT_MEDIA_TRANSPORT_INPUT = 0x0202
+};
+
+/** Output terminal type (B.3) */
+enum uvc_ot_type {
+  UVC_OTT_VENDOR_SPECIFIC = 0x0300,
+  UVC_OTT_DISPLAY = 0x0301,
+  UVC_OTT_MEDIA_TRANSPORT_OUTPUT = 0x0302
+};
+
+/** External terminal type (B.4) */
+enum uvc_et_type {
+  UVC_EXTERNAL_VENDOR_SPECIFIC = 0x0400,
+  UVC_COMPOSITE_CONNECTOR = 0x0401,
+  UVC_SVIDEO_CONNECTOR = 0x0402,
+  UVC_COMPONENT_CONNECTOR = 0x0403
+};
+
+/** Context, equivalent to libusb's contexts.
+ *
+ * May either own a libusb context or use one that's already made.
+ *
+ * Always create these with uvc_get_context.
+ */
+struct uvc_context;
+typedef struct uvc_context uvc_context_t;
+
+/** UVC device.
+ *
+ * Get this from uvc_get_device_list() or uvc_find_device().
+ */
+struct uvc_device;
+typedef struct uvc_device uvc_device_t;
+
+/** Handle on an open UVC device.
+ *
+ * Get one of these from uvc_open(). Once you uvc_close()
+ * it, it's no longer valid.
+ */
+struct uvc_device_handle;
+typedef struct uvc_device_handle uvc_device_handle_t;
+
+/** Handle on an open UVC stream.
+ *
+ * Get one of these from uvc_stream_open*().
+ * Once you uvc_stream_close() it, it will no longer be valid.
+ */
+struct uvc_stream_handle;
+typedef struct uvc_stream_handle uvc_stream_handle_t;
+
+/** Representation of the interface that brings data into the UVC device */
+typedef struct uvc_input_terminal {
+  struct uvc_input_terminal *prev, *next;
+  /** Index of the terminal within the device */
+  uint8_t bTerminalID;
+  /** Type of terminal (e.g., camera) */
+  enum uvc_it_type wTerminalType;
+  uint16_t wObjectiveFocalLengthMin;
+  uint16_t wObjectiveFocalLengthMax;
+  uint16_t wOcularFocalLength;
+  /** Camera controls (meaning of bits given in {uvc_ct_ctrl_selector}) */
+  uint64_t bmControls;
+} uvc_input_terminal_t;
+
+typedef struct uvc_output_terminal {
+  struct uvc_output_terminal *prev, *next;
+  /** @todo */
+} uvc_output_terminal_t;
+
+/** Represents post-capture processing functions */
+typedef struct uvc_processing_unit {
+  struct uvc_processing_unit *prev, *next;
+  /** Index of the processing unit within the device */
+  uint8_t bUnitID;
+  /** Index of the terminal from which the device accepts images */
+  uint8_t bSourceID;
+  /** Processing controls (meaning of bits given in {uvc_pu_ctrl_selector}) */
+  uint64_t bmControls;
+} uvc_processing_unit_t;
+
+/** Represents selector unit to connect other units */
+typedef struct uvc_selector_unit {
+  struct uvc_selector_unit *prev, *next;
+  /** Index of the selector unit within the device */
+  uint8_t bUnitID;
+} uvc_selector_unit_t;
+
+/** Custom processing or camera-control functions */
+typedef struct uvc_extension_unit {
+  struct uvc_extension_unit *prev, *next;
+  /** Index of the extension unit within the device */
+  uint8_t bUnitID;
+  /** GUID identifying the extension unit */
+  uint8_t guidExtensionCode[16];
+  /** Bitmap of available controls (manufacturer-dependent) */
+  uint64_t bmControls;
+} uvc_extension_unit_t;
+
+enum uvc_status_class {
+  UVC_STATUS_CLASS_CONTROL = 0x10,
+  UVC_STATUS_CLASS_CONTROL_CAMERA = 0x11,
+  UVC_STATUS_CLASS_CONTROL_PROCESSING = 0x12,
+};
+
+enum uvc_status_attribute {
+  UVC_STATUS_ATTRIBUTE_VALUE_CHANGE = 0x00,
+  UVC_STATUS_ATTRIBUTE_INFO_CHANGE = 0x01,
+  UVC_STATUS_ATTRIBUTE_FAILURE_CHANGE = 0x02,
+  UVC_STATUS_ATTRIBUTE_UNKNOWN = 0xff
+};
+
+/** A callback function to accept status updates
+ * @ingroup device
+ */
+typedef void(uvc_status_callback_t)(enum uvc_status_class status_class,
+                                    int event,
+                                    int selector,
+                                    enum uvc_status_attribute status_attribute,
+                                    void *data, size_t data_len,
+                                    void *user_ptr);
+
+/** A callback function to accept button events
+ * @ingroup device
+ */
+typedef void(uvc_button_callback_t)(int button,
+                                    int state,
+                                    void *user_ptr);
+
+/** Structure representing a UVC device descriptor.
+ *
+ * (This isn't a standard structure.)
+ */
+typedef struct uvc_device_descriptor {
+  /** Vendor ID */
+  uint16_t idVendor;
+  /** Product ID */
+  uint16_t idProduct;
+  /** UVC compliance level, e.g. 0x0100 (1.0), 0x0110 */
+  uint16_t bcdUVC;
+  /** Serial number (null if unavailable) */
+  const char *serialNumber;
+  /** Device-reported manufacturer name (or null) */
+  const char *manufacturer;
+  /** Device-reporter product name (or null) */
+  const char *product;
+} uvc_device_descriptor_t;
+
+/** An image frame received from the UVC device
+ * @ingroup streaming
+ */
+typedef struct uvc_frame {
+  /** Image data for this frame */
+  void *data;
+  /** Size of image data buffer */
+  size_t data_bytes;
+  /** Width of image in pixels */
+  uint32_t width;
+  /** Height of image in pixels */
+  uint32_t height;
+  /** Pixel data format */
+  enum uvc_frame_format frame_format;
+  /** Number of bytes per horizontal line (undefined for compressed format) */
+  size_t step;
+  /** Frame number (may skip, but is strictly monotonically increasing) */
+  uint32_t sequence;
+  /** Estimate of system time when the device started capturing the image */
+  struct timeval capture_time;
+  /** Estimate of system time when the device finished receiving the image */
+  struct timespec capture_time_finished;
+  /** Handle on the device that produced the image.
+   * @warning You must not call any uvc_* functions during a callback. */
+  uvc_device_handle_t *source;
+  /** Is the data buffer owned by the library?
+   * If 1, the data buffer can be arbitrarily reallocated by frame conversion
+   * functions.
+   * If 0, the data buffer will not be reallocated or freed by the library.
+   * Set this field to zero if you are supplying the buffer.
+   */
+  uint8_t library_owns_data;
+  /** Metadata for this frame if available */
+  void *metadata;
+  /** Size of metadata buffer */
+  size_t metadata_bytes;
+} uvc_frame_t;
+
+/** A callback function to handle incoming assembled UVC frames
+ * @ingroup streaming
+ */
+typedef void(uvc_frame_callback_t)(struct uvc_frame *frame, void *user_ptr);
+
+/** Streaming mode, includes all information needed to select stream
+ * @ingroup streaming
+ */
+typedef struct uvc_stream_ctrl {
+  uint16_t bmHint;
+  uint8_t bFormatIndex;
+  uint8_t bFrameIndex;
+  uint32_t dwFrameInterval;
+  uint16_t wKeyFrameRate;
+  uint16_t wPFrameRate;
+  uint16_t wCompQuality;
+  uint16_t wCompWindowSize;
+  uint16_t wDelay;
+  uint32_t dwMaxVideoFrameSize;
+  uint32_t dwMaxPayloadTransferSize;
+  uint32_t dwClockFrequency;
+  uint8_t bmFramingInfo;
+  uint8_t bPreferredVersion;
+  uint8_t bMinVersion;
+  uint8_t bMaxVersion;
+  uint8_t bInterfaceNumber;
+} uvc_stream_ctrl_t;
+
+typedef struct uvc_still_ctrl {
+  /* Video format index from a format descriptor */
+  uint8_t bFormatIndex;
+  /* Video frame index from a frame descriptor */
+  uint8_t bFrameIndex;
+  /* Compression index from a frame descriptor */
+  uint8_t bCompressionIndex;
+  /* Maximum still image size in bytes. */
+  uint32_t dwMaxVideoFrameSize;
+  /* Maximum number of byte per payload*/
+  uint32_t dwMaxPayloadTransferSize;
+  uint8_t bInterfaceNumber;
+} uvc_still_ctrl_t;
+
+uvc_error_t uvc_init(uvc_context_t **ctx, struct libusb_context *usb_ctx);
+void uvc_exit(uvc_context_t *ctx);
+
+uvc_error_t uvc_get_device_list(
+    uvc_context_t *ctx,
+    uvc_device_t ***list);
+void uvc_free_device_list(uvc_device_t **list, uint8_t unref_devices);
+
+uvc_error_t uvc_get_device_descriptor(
+    uvc_device_t *dev,
+    uvc_device_descriptor_t **desc);
+void uvc_free_device_descriptor(
+    uvc_device_descriptor_t *desc);
+
+uint8_t uvc_get_bus_number(uvc_device_t *dev);
+uint8_t uvc_get_device_address(uvc_device_t *dev);
+/** Get the USB port path below the device's root hub. */
+int uvc_get_port_numbers(uvc_device_t *dev, uint8_t *ports,
+                         uint8_t port_count);
+
+uvc_error_t uvc_find_device(
+    uvc_context_t *ctx,
+    uvc_device_t **dev,
+    int vid, int pid, const char *sn);
+
+uvc_error_t uvc_find_devices(
+    uvc_context_t *ctx,
+    uvc_device_t ***devs,
+    int vid, int pid, const char *sn);
+
+#if LIBUSB_API_VERSION >= 0x01000107
+uvc_error_t uvc_wrap(
+    int sys_dev,
+    uvc_context_t *context,
+    uvc_device_handle_t **devh);
+#endif
+
+uvc_error_t uvc_open(
+    uvc_device_t *dev,
+    uvc_device_handle_t **devh);
+void uvc_close(uvc_device_handle_t *devh);
+
+uvc_device_t *uvc_get_device(uvc_device_handle_t *devh);
+struct libusb_device_handle *uvc_get_libusb_handle(uvc_device_handle_t *devh);
+
+/** Pin the altsetting (and hence the ISO payload) used for this device.
+ *
+ * The compile-time quirks table in stream.c is a per-model default. A caller
+ * that has measured which setting actually holds for a particular camera and
+ * host can override it per open device handle. The override is applied to every
+ * stream opened on this handle and wins over the table; pass altsetting <= 0 to
+ * clear it and fall back to the table. It takes effect on the next
+ * uvc_start_streaming()/uvc_stream_start(); it does not touch a running stream.
+ *
+ * @param[in] devh Device handle from uvc_open()
+ * @param[in] altsetting bAlternateSetting to force, or <= 0 to clear
+ * @param[in] payload Payload in bytes to commit and size the ISO transfers for
+ * @ingroup stream
+ */
+uvc_error_t uvc_set_altsetting_override(
+    uvc_device_handle_t *devh,
+    int altsetting,
+    unsigned int payload);
+
+void uvc_ref_device(uvc_device_t *dev);
+void uvc_unref_device(uvc_device_t *dev);
+
+void uvc_set_status_callback(uvc_device_handle_t *devh,
+                             uvc_status_callback_t cb,
+                             void *user_ptr);
+
+void uvc_set_button_callback(uvc_device_handle_t *devh,
+                             uvc_button_callback_t cb,
+                             void *user_ptr);
+
+const uvc_input_terminal_t *uvc_get_camera_terminal(uvc_device_handle_t *devh);
+const uvc_input_terminal_t *uvc_get_input_terminals(uvc_device_handle_t *devh);
+const uvc_output_terminal_t *uvc_get_output_terminals(uvc_device_handle_t *devh);
+const uvc_selector_unit_t *uvc_get_selector_units(uvc_device_handle_t *devh);
+const uvc_processing_unit_t *uvc_get_processing_units(uvc_device_handle_t *devh);
+const uvc_extension_unit_t *uvc_get_extension_units(uvc_device_handle_t *devh);
+
+uvc_error_t uvc_get_stream_ctrl_format_size(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    enum uvc_frame_format format,
+    int width, int height,
+    int fps
+    );
+
+uvc_error_t uvc_get_still_ctrl_format_size(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    uvc_still_ctrl_t *still_ctrl,
+    int width, int height);
+
+uvc_error_t uvc_trigger_still(
+    uvc_device_handle_t *devh,
+    uvc_still_ctrl_t *still_ctrl);
+
+const uvc_format_desc_t *uvc_get_format_descs(uvc_device_handle_t* );
+
+uvc_error_t uvc_probe_stream_ctrl(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl);
+
+uvc_error_t uvc_probe_still_ctrl(
+    uvc_device_handle_t *devh,
+    uvc_still_ctrl_t *still_ctrl);
+
+uvc_error_t uvc_start_streaming(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    uvc_frame_callback_t *cb,
+    void *user_ptr,
+    uint8_t flags);
+
+uvc_error_t uvc_start_iso_streaming(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    uvc_frame_callback_t *cb,
+    void *user_ptr);
+
+void uvc_stop_streaming(uvc_device_handle_t *devh);
+
+uvc_error_t uvc_stream_open_ctrl(uvc_device_handle_t *devh, uvc_stream_handle_t **strmh, uvc_stream_ctrl_t *ctrl);
+uvc_error_t uvc_stream_ctrl(uvc_stream_handle_t *strmh, uvc_stream_ctrl_t *ctrl);
+uvc_error_t uvc_stream_start(uvc_stream_handle_t *strmh,
+    uvc_frame_callback_t *cb,
+    void *user_ptr,
+    uint8_t flags);
+uvc_error_t uvc_stream_start_iso(uvc_stream_handle_t *strmh,
+    uvc_frame_callback_t *cb,
+    void *user_ptr);
+uvc_error_t uvc_stream_get_frame(
+    uvc_stream_handle_t *strmh,
+    uvc_frame_t **frame,
+    int32_t timeout_us
+);
+uvc_error_t uvc_stream_stop(uvc_stream_handle_t *strmh);
+void uvc_stream_close(uvc_stream_handle_t *strmh);
+
+int uvc_get_ctrl_len(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl);
+int uvc_get_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len, enum uvc_req_code req_code);
+int uvc_set_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len);
+
+uvc_error_t uvc_get_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode *mode, enum uvc_req_code req_code);
+uvc_error_t uvc_set_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode mode);
+
+/* AUTO-GENERATED control accessors! Update them with the output of `ctrl-gen.py decl`. */
+uvc_error_t uvc_get_scanning_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code);
+uvc_error_t uvc_set_scanning_mode(uvc_device_handle_t *devh, uint8_t mode);
+
+uvc_error_t uvc_get_ae_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code);
+uvc_error_t uvc_set_ae_mode(uvc_device_handle_t *devh, uint8_t mode);
+
+uvc_error_t uvc_get_ae_priority(uvc_device_handle_t *devh, uint8_t* priority, enum uvc_req_code req_code);
+uvc_error_t uvc_set_ae_priority(uvc_device_handle_t *devh, uint8_t priority);
+
+uvc_error_t uvc_get_exposure_abs(uvc_device_handle_t *devh, uint32_t* time, enum uvc_req_code req_code);
+uvc_error_t uvc_set_exposure_abs(uvc_device_handle_t *devh, uint32_t time);
+
+uvc_error_t uvc_get_exposure_rel(uvc_device_handle_t *devh, int8_t* step, enum uvc_req_code req_code);
+uvc_error_t uvc_set_exposure_rel(uvc_device_handle_t *devh, int8_t step);
+
+uvc_error_t uvc_get_focus_abs(uvc_device_handle_t *devh, uint16_t* focus, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_abs(uvc_device_handle_t *devh, uint16_t focus);
+
+uvc_error_t uvc_get_focus_rel(uvc_device_handle_t *devh, int8_t* focus_rel, uint8_t* speed, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_rel(uvc_device_handle_t *devh, int8_t focus_rel, uint8_t speed);
+
+uvc_error_t uvc_get_focus_simple_range(uvc_device_handle_t *devh, uint8_t* focus, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_simple_range(uvc_device_handle_t *devh, uint8_t focus);
+
+uvc_error_t uvc_get_focus_auto(uvc_device_handle_t *devh, uint8_t* state, enum uvc_req_code req_code);
+uvc_error_t uvc_set_focus_auto(uvc_device_handle_t *devh, uint8_t state);
+
+uvc_error_t uvc_get_iris_abs(uvc_device_handle_t *devh, uint16_t* iris, enum uvc_req_code req_code);
+uvc_error_t uvc_set_iris_abs(uvc_device_handle_t *devh, uint16_t iris);
+
+uvc_error_t uvc_get_iris_rel(uvc_device_handle_t *devh, uint8_t* iris_rel, enum uvc_req_code req_code);
+uvc_error_t uvc_set_iris_rel(uvc_device_handle_t *devh, uint8_t iris_rel);
+
+uvc_error_t uvc_get_zoom_abs(uvc_device_handle_t *devh, uint16_t* focal_length, enum uvc_req_code req_code);
+uvc_error_t uvc_set_zoom_abs(uvc_device_handle_t *devh, uint16_t focal_length);
+
+uvc_error_t uvc_get_zoom_rel(uvc_device_handle_t *devh, int8_t* zoom_rel, uint8_t* digital_zoom, uint8_t* speed, enum uvc_req_code req_code);
+uvc_error_t uvc_set_zoom_rel(uvc_device_handle_t *devh, int8_t zoom_rel, uint8_t digital_zoom, uint8_t speed);
+
+uvc_error_t uvc_get_pantilt_abs(uvc_device_handle_t *devh, int32_t* pan, int32_t* tilt, enum uvc_req_code req_code);
+uvc_error_t uvc_set_pantilt_abs(uvc_device_handle_t *devh, int32_t pan, int32_t tilt);
+
+uvc_error_t uvc_get_pantilt_rel(uvc_device_handle_t *devh, int8_t* pan_rel, uint8_t* pan_speed, int8_t* tilt_rel, uint8_t* tilt_speed, enum uvc_req_code req_code);
+uvc_error_t uvc_set_pantilt_rel(uvc_device_handle_t *devh, int8_t pan_rel, uint8_t pan_speed, int8_t tilt_rel, uint8_t tilt_speed);
+
+uvc_error_t uvc_get_roll_abs(uvc_device_handle_t *devh, int16_t* roll, enum uvc_req_code req_code);
+uvc_error_t uvc_set_roll_abs(uvc_device_handle_t *devh, int16_t roll);
+
+uvc_error_t uvc_get_roll_rel(uvc_device_handle_t *devh, int8_t* roll_rel, uint8_t* speed, enum uvc_req_code req_code);
+uvc_error_t uvc_set_roll_rel(uvc_device_handle_t *devh, int8_t roll_rel, uint8_t speed);
+
+uvc_error_t uvc_get_privacy(uvc_device_handle_t *devh, uint8_t* privacy, enum uvc_req_code req_code);
+uvc_error_t uvc_set_privacy(uvc_device_handle_t *devh, uint8_t privacy);
+
+uvc_error_t uvc_get_digital_window(uvc_device_handle_t *devh, uint16_t* window_top, uint16_t* window_left, uint16_t* window_bottom, uint16_t* window_right, uint16_t* num_steps, uint16_t* num_steps_units, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_window(uvc_device_handle_t *devh, uint16_t window_top, uint16_t window_left, uint16_t window_bottom, uint16_t window_right, uint16_t num_steps, uint16_t num_steps_units);
+
+uvc_error_t uvc_get_digital_roi(uvc_device_handle_t *devh, uint16_t* roi_top, uint16_t* roi_left, uint16_t* roi_bottom, uint16_t* roi_right, uint16_t* auto_controls, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_roi(uvc_device_handle_t *devh, uint16_t roi_top, uint16_t roi_left, uint16_t roi_bottom, uint16_t roi_right, uint16_t auto_controls);
+
+uvc_error_t uvc_get_backlight_compensation(uvc_device_handle_t *devh, uint16_t* backlight_compensation, enum uvc_req_code req_code);
+uvc_error_t uvc_set_backlight_compensation(uvc_device_handle_t *devh, uint16_t backlight_compensation);
+
+uvc_error_t uvc_get_brightness(uvc_device_handle_t *devh, int16_t* brightness, enum uvc_req_code req_code);
+uvc_error_t uvc_set_brightness(uvc_device_handle_t *devh, int16_t brightness);
+
+uvc_error_t uvc_get_contrast(uvc_device_handle_t *devh, uint16_t* contrast, enum uvc_req_code req_code);
+uvc_error_t uvc_set_contrast(uvc_device_handle_t *devh, uint16_t contrast);
+
+uvc_error_t uvc_get_contrast_auto(uvc_device_handle_t *devh, uint8_t* contrast_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_contrast_auto(uvc_device_handle_t *devh, uint8_t contrast_auto);
+
+uvc_error_t uvc_get_gain(uvc_device_handle_t *devh, uint16_t* gain, enum uvc_req_code req_code);
+uvc_error_t uvc_set_gain(uvc_device_handle_t *devh, uint16_t gain);
+
+uvc_error_t uvc_get_power_line_frequency(uvc_device_handle_t *devh, uint8_t* power_line_frequency, enum uvc_req_code req_code);
+uvc_error_t uvc_set_power_line_frequency(uvc_device_handle_t *devh, uint8_t power_line_frequency);
+
+uvc_error_t uvc_get_hue(uvc_device_handle_t *devh, int16_t* hue, enum uvc_req_code req_code);
+uvc_error_t uvc_set_hue(uvc_device_handle_t *devh, int16_t hue);
+
+uvc_error_t uvc_get_hue_auto(uvc_device_handle_t *devh, uint8_t* hue_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_hue_auto(uvc_device_handle_t *devh, uint8_t hue_auto);
+
+uvc_error_t uvc_get_saturation(uvc_device_handle_t *devh, uint16_t* saturation, enum uvc_req_code req_code);
+uvc_error_t uvc_set_saturation(uvc_device_handle_t *devh, uint16_t saturation);
+
+uvc_error_t uvc_get_sharpness(uvc_device_handle_t *devh, uint16_t* sharpness, enum uvc_req_code req_code);
+uvc_error_t uvc_set_sharpness(uvc_device_handle_t *devh, uint16_t sharpness);
+
+uvc_error_t uvc_get_gamma(uvc_device_handle_t *devh, uint16_t* gamma, enum uvc_req_code req_code);
+uvc_error_t uvc_set_gamma(uvc_device_handle_t *devh, uint16_t gamma);
+
+uvc_error_t uvc_get_white_balance_temperature(uvc_device_handle_t *devh, uint16_t* temperature, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_temperature(uvc_device_handle_t *devh, uint16_t temperature);
+
+uvc_error_t uvc_get_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t* temperature_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t temperature_auto);
+
+uvc_error_t uvc_get_white_balance_component(uvc_device_handle_t *devh, uint16_t* blue, uint16_t* red, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_component(uvc_device_handle_t *devh, uint16_t blue, uint16_t red);
+
+uvc_error_t uvc_get_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t* white_balance_component_auto, enum uvc_req_code req_code);
+uvc_error_t uvc_set_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t white_balance_component_auto);
+
+uvc_error_t uvc_get_digital_multiplier(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_multiplier(uvc_device_handle_t *devh, uint16_t multiplier_step);
+
+uvc_error_t uvc_get_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code);
+uvc_error_t uvc_set_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t multiplier_step);
+
+uvc_error_t uvc_get_analog_video_standard(uvc_device_handle_t *devh, uint8_t* video_standard, enum uvc_req_code req_code);
+uvc_error_t uvc_set_analog_video_standard(uvc_device_handle_t *devh, uint8_t video_standard);
+
+uvc_error_t uvc_get_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t* status, enum uvc_req_code req_code);
+uvc_error_t uvc_set_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t status);
+
+uvc_error_t uvc_get_input_select(uvc_device_handle_t *devh, uint8_t* selector, enum uvc_req_code req_code);
+uvc_error_t uvc_set_input_select(uvc_device_handle_t *devh, uint8_t selector);
+/* end AUTO-GENERATED control accessors */
+
+void uvc_perror(uvc_error_t err, const char *msg);
+const char* uvc_strerror(uvc_error_t err);
+void uvc_print_diag(uvc_device_handle_t *devh, FILE *stream);
+void uvc_print_stream_ctrl(uvc_stream_ctrl_t *ctrl, FILE *stream);
+
+uvc_frame_t *uvc_allocate_frame(size_t data_bytes);
+void uvc_free_frame(uvc_frame_t *frame);
+
+uvc_error_t uvc_duplicate_frame(uvc_frame_t *in, uvc_frame_t *out);
+
+uvc_error_t uvc_yuyv2rgb(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_uyvy2rgb(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_any2rgb(uvc_frame_t *in, uvc_frame_t *out);
+
+uvc_error_t uvc_yuyv2bgr(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_uyvy2bgr(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_any2bgr(uvc_frame_t *in, uvc_frame_t *out);
+
+uvc_error_t uvc_yuyv2y(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_yuyv2uv(uvc_frame_t *in, uvc_frame_t *out);
+
+#ifdef LIBUVC_HAS_JPEG
+uvc_error_t uvc_mjpeg2rgb(uvc_frame_t *in, uvc_frame_t *out);
+uvc_error_t uvc_mjpeg2gray(uvc_frame_t *in, uvc_frame_t *out);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !def(LIBUVC_H)

collector/core/gripper/camera_service_src/third_party/libuvc/include/libuvc/libuvc_config.h.in

@@ -0,0 +1,22 @@
+#ifndef LIBUVC_CONFIG_H
+#define LIBUVC_CONFIG_H
+
+#define LIBUVC_VERSION_MAJOR @libuvc_VERSION_MAJOR@
+#define LIBUVC_VERSION_MINOR @libuvc_VERSION_MINOR@
+#define LIBUVC_VERSION_PATCH @libuvc_VERSION_PATCH@
+#define LIBUVC_VERSION_STR "@libuvc_VERSION@"
+#define LIBUVC_VERSION_INT                      \
+  ((@libuvc_VERSION_MAJOR@ << 16) |             \
+   (@libuvc_VERSION_MINOR@ << 8) |              \
+   (@libuvc_VERSION_PATCH@))
+
+/** @brief Test whether libuvc is new enough
+ * This macro evaluates true if and only if the current version is
+ * at least as new as the version specified.
+ */
+#define LIBUVC_VERSION_GTE(major, minor, patch)                         \
+  (LIBUVC_VERSION_INT >= (((major) << 16) | ((minor) << 8) | (patch)))
+
+#cmakedefine LIBUVC_HAS_JPEG 1
+
+#endif // !def(LIBUVC_CONFIG_H)

collector/core/gripper/camera_service_src/third_party/libuvc/include/libuvc/libuvc_internal.h

@@ -0,0 +1,326 @@
+/** @file libuvc_internal.h
+  * @brief Implementation-specific UVC constants and structures.
+  * @cond include_hidden
+  */
+#ifndef LIBUVC_INTERNAL_H
+#define LIBUVC_INTERNAL_H
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <signal.h>
+#include <libusb.h>
+#include "utlist.h"
+
+/** Converts an unaligned four-byte little-endian integer into an int32 */
+#define DW_TO_INT(p) ((p)[0] | ((p)[1] << 8) | ((p)[2] << 16) | ((p)[3] << 24))
+/** Converts an unaligned two-byte little-endian integer into an int16 */
+#define SW_TO_SHORT(p) ((p)[0] | ((p)[1] << 8))
+/** Converts an int16 into an unaligned two-byte little-endian integer */
+#define SHORT_TO_SW(s, p) \
+  (p)[0] = (s); \
+  (p)[1] = (s) >> 8;
+/** Converts an int32 into an unaligned four-byte little-endian integer */
+#define INT_TO_DW(i, p) \
+  (p)[0] = (i); \
+  (p)[1] = (i) >> 8; \
+  (p)[2] = (i) >> 16; \
+  (p)[3] = (i) >> 24;
+
+/** Selects the nth item in a doubly linked list. n=-1 selects the last item. */
+#define DL_NTH(head, out, n) \
+  do { \
+    int dl_nth_i = 0; \
+    LDECLTYPE(head) dl_nth_p = (head); \
+    if ((n) < 0) { \
+      while (dl_nth_p && dl_nth_i > (n)) { \
+        dl_nth_p = dl_nth_p->prev; \
+        dl_nth_i--; \
+      } \
+    } else { \
+      while (dl_nth_p && dl_nth_i < (n)) { \
+        dl_nth_p = dl_nth_p->next; \
+        dl_nth_i++; \
+      } \
+    } \
+    (out) = dl_nth_p; \
+  } while (0);
+
+#ifdef UVC_DEBUGGING
+#include <libgen.h>
+#ifdef __ANDROID__
+#include <android/log.h>
+#define UVC_DEBUG(format, ...) __android_log_print(ANDROID_LOG_DEBUG, "libuvc", "[%s:%d/%s] " format "\n", basename(__FILE__), __LINE__, __FUNCTION__, ##__VA_ARGS__)
+#define UVC_ENTER() __android_log_print(ANDROID_LOG_DEBUG, "libuvc", "[%s:%d] begin %s\n", basename(__FILE__), __LINE__, __FUNCTION__)
+#define UVC_EXIT(code) __android_log_print(ANDROID_LOG_DEBUG, "libuvc", "[%s:%d] end %s (%d)\n", basename(__FILE__), __LINE__, __FUNCTION__, code)
+#define UVC_EXIT_VOID() __android_log_print(ANDROID_LOG_DEBUG, "libuvc", "[%s:%d] end %s\n", basename(__FILE__), __LINE__, __FUNCTION__)
+#else
+#define UVC_DEBUG(format, ...) fprintf(stderr, "[%s:%d/%s] " format "\n", basename(__FILE__), __LINE__, __FUNCTION__, ##__VA_ARGS__)
+#define UVC_ENTER() fprintf(stderr, "[%s:%d] begin %s\n", basename(__FILE__), __LINE__, __FUNCTION__)
+#define UVC_EXIT(code) fprintf(stderr, "[%s:%d] end %s (%d)\n", basename(__FILE__), __LINE__, __FUNCTION__, code)
+#define UVC_EXIT_VOID() fprintf(stderr, "[%s:%d] end %s\n", basename(__FILE__), __LINE__, __FUNCTION__)
+#endif
+#else
+#define UVC_DEBUG(format, ...)
+#define UVC_ENTER()
+#define UVC_EXIT_VOID()
+#define UVC_EXIT(code)
+#endif
+
+/* http://stackoverflow.com/questions/19452971/array-size-macro-that-rejects-pointers */
+#define IS_INDEXABLE(arg) (sizeof(arg[0]))
+#define IS_ARRAY(arg) (IS_INDEXABLE(arg) && (((void *) &arg) == ((void *) arg)))
+#define ARRAYSIZE(arr) (sizeof(arr) / (IS_ARRAY(arr) ? sizeof(arr[0]) : 0))
+
+/** Video interface subclass code (A.2) */
+enum uvc_int_subclass_code {
+  UVC_SC_UNDEFINED = 0x00,
+  UVC_SC_VIDEOCONTROL = 0x01,
+  UVC_SC_VIDEOSTREAMING = 0x02,
+  UVC_SC_VIDEO_INTERFACE_COLLECTION = 0x03
+};
+
+/** Video interface protocol code (A.3) */
+enum uvc_int_proto_code {
+  UVC_PC_PROTOCOL_UNDEFINED = 0x00
+};
+
+/** VideoControl interface descriptor subtype (A.5) */
+enum uvc_vc_desc_subtype {
+  UVC_VC_DESCRIPTOR_UNDEFINED = 0x00,
+  UVC_VC_HEADER = 0x01,
+  UVC_VC_INPUT_TERMINAL = 0x02,
+  UVC_VC_OUTPUT_TERMINAL = 0x03,
+  UVC_VC_SELECTOR_UNIT = 0x04,
+  UVC_VC_PROCESSING_UNIT = 0x05,
+  UVC_VC_EXTENSION_UNIT = 0x06
+};
+
+/** UVC endpoint descriptor subtype (A.7) */
+enum uvc_ep_desc_subtype {
+  UVC_EP_UNDEFINED = 0x00,
+  UVC_EP_GENERAL = 0x01,
+  UVC_EP_ENDPOINT = 0x02,
+  UVC_EP_INTERRUPT = 0x03
+};
+
+/** VideoControl interface control selector (A.9.1) */
+enum uvc_vc_ctrl_selector {
+  UVC_VC_CONTROL_UNDEFINED = 0x00,
+  UVC_VC_VIDEO_POWER_MODE_CONTROL = 0x01,
+  UVC_VC_REQUEST_ERROR_CODE_CONTROL = 0x02
+};
+
+/** Terminal control selector (A.9.2) */
+enum uvc_term_ctrl_selector {
+  UVC_TE_CONTROL_UNDEFINED = 0x00
+};
+
+/** Selector unit control selector (A.9.3) */
+enum uvc_su_ctrl_selector {
+  UVC_SU_CONTROL_UNDEFINED = 0x00,
+  UVC_SU_INPUT_SELECT_CONTROL = 0x01
+};
+
+/** Extension unit control selector (A.9.6) */
+enum uvc_xu_ctrl_selector {
+  UVC_XU_CONTROL_UNDEFINED = 0x00
+};
+
+/** VideoStreaming interface control selector (A.9.7) */
+enum uvc_vs_ctrl_selector {
+  UVC_VS_CONTROL_UNDEFINED = 0x00,
+  UVC_VS_PROBE_CONTROL = 0x01,
+  UVC_VS_COMMIT_CONTROL = 0x02,
+  UVC_VS_STILL_PROBE_CONTROL = 0x03,
+  UVC_VS_STILL_COMMIT_CONTROL = 0x04,
+  UVC_VS_STILL_IMAGE_TRIGGER_CONTROL = 0x05,
+  UVC_VS_STREAM_ERROR_CODE_CONTROL = 0x06,
+  UVC_VS_GENERATE_KEY_FRAME_CONTROL = 0x07,
+  UVC_VS_UPDATE_FRAME_SEGMENT_CONTROL = 0x08,
+  UVC_VS_SYNC_DELAY_CONTROL = 0x09
+};
+
+/** Status packet type (2.4.2.2) */
+enum uvc_status_type {
+  UVC_STATUS_TYPE_CONTROL = 1,
+  UVC_STATUS_TYPE_STREAMING = 2
+};
+
+/** Payload header flags (2.4.3.3) */
+#define UVC_STREAM_EOH (1 << 7)
+#define UVC_STREAM_ERR (1 << 6)
+#define UVC_STREAM_STI (1 << 5)
+#define UVC_STREAM_RES (1 << 4)
+#define UVC_STREAM_SCR (1 << 3)
+#define UVC_STREAM_PTS (1 << 2)
+#define UVC_STREAM_EOF (1 << 1)
+#define UVC_STREAM_FID (1 << 0)
+
+/** Control capabilities (4.1.2) */
+#define UVC_CONTROL_CAP_GET (1 << 0)
+#define UVC_CONTROL_CAP_SET (1 << 1)
+#define UVC_CONTROL_CAP_DISABLED (1 << 2)
+#define UVC_CONTROL_CAP_AUTOUPDATE (1 << 3)
+#define UVC_CONTROL_CAP_ASYNCHRONOUS (1 << 4)
+
+struct uvc_streaming_interface;
+struct uvc_device_info;
+
+/** VideoStream interface */
+typedef struct uvc_streaming_interface {
+  struct uvc_device_info *parent;
+  struct uvc_streaming_interface *prev, *next;
+  /** Interface number */
+  uint8_t bInterfaceNumber;
+  /** Video formats that this interface provides */
+  struct uvc_format_desc *format_descs;
+  /** USB endpoint to use when communicating with this interface */
+  uint8_t bEndpointAddress;
+  uint8_t bTerminalLink;
+  uint8_t bStillCaptureMethod;
+} uvc_streaming_interface_t;
+
+/** VideoControl interface */
+typedef struct uvc_control_interface {
+  struct uvc_device_info *parent;
+  struct uvc_input_terminal *input_term_descs;
+  // struct uvc_output_terminal *output_term_descs;
+  struct uvc_selector_unit *selector_unit_descs;
+  struct uvc_processing_unit *processing_unit_descs;
+  struct uvc_extension_unit *extension_unit_descs;
+  uint16_t bcdUVC;
+  uint32_t dwClockFrequency;
+  uint8_t bEndpointAddress;
+  /** Interface number */
+  uint8_t bInterfaceNumber;
+} uvc_control_interface_t;
+
+struct uvc_stream_ctrl;
+
+struct uvc_device {
+  struct uvc_context *ctx;
+  int ref;
+  libusb_device *usb_dev;
+};
+
+typedef struct uvc_device_info {
+  /** Configuration descriptor for USB device */
+  struct libusb_config_descriptor *config;
+  /** VideoControl interface provided by device */
+  uvc_control_interface_t ctrl_if;
+  /** VideoStreaming interfaces on the device */
+  uvc_streaming_interface_t *stream_ifs;
+} uvc_device_info_t;
+
+/*
+  The default Linux value of 100 is too deep for this service: six USB2
+  isochronous cameras would submit 600 transfers (up to 32 packets each),
+  exhausting the libusb/xHCI in-flight scheduling resources before all
+  endpoints receive callbacks. Eight transfers per camera provide 32 ms of
+  queued ISO work at the selected endpoint size and keep all six streams
+  active. This remains overridable at compile time for other applications.
+ */
+#ifndef LIBUVC_NUM_TRANSFER_BUFS
+#if defined(__APPLE__) && defined(__MACH__)
+#define LIBUVC_NUM_TRANSFER_BUFS 20
+#else
+#define LIBUVC_NUM_TRANSFER_BUFS 8
+#endif
+#endif
+
+#define LIBUVC_XFER_META_BUF_SIZE ( 4 * 1024 )
+
+struct uvc_stream_handle {
+  struct uvc_device_handle *devh;
+  struct uvc_stream_handle *prev, *next;
+  struct uvc_streaming_interface *stream_if;
+
+  /** if true, stream is running (streaming video to host) */
+  uint8_t running;
+  /** Current control block */
+  struct uvc_stream_ctrl cur_ctrl;
+
+  /* listeners may only access hold*, and only when holding a
+   * lock on cb_mutex (probably signaled with cb_cond) */
+  uint8_t fid;
+  uint32_t seq, hold_seq;
+  uint32_t pts, hold_pts;
+  uint32_t last_scr, hold_last_scr;
+  size_t got_bytes, hold_bytes;
+  uint8_t *outbuf, *holdbuf;
+  pthread_mutex_t cb_mutex;
+  pthread_cond_t cb_cond;
+  pthread_t cb_thread;
+  uint32_t last_polled_seq;
+  uvc_frame_callback_t *user_cb;
+  void *user_ptr;
+  struct libusb_transfer *transfers[LIBUVC_NUM_TRANSFER_BUFS];
+  uint8_t *transfer_bufs[LIBUVC_NUM_TRANSFER_BUFS];
+  struct uvc_frame frame;
+  enum uvc_frame_format frame_format;
+  struct timespec capture_time_finished;
+
+  /* raw metadata buffer if available */
+  uint8_t *meta_outbuf, *meta_holdbuf;
+  size_t meta_got_bytes, meta_hold_bytes;
+};
+
+/** Handle on an open UVC device
+ *
+ * @todo move most of this into a uvc_device struct?
+ */
+struct uvc_device_handle {
+  struct uvc_device *dev;
+  struct uvc_device_handle *prev, *next;
+  /** Underlying USB device handle */
+  libusb_device_handle *usb_devh;
+  struct uvc_device_info *info;
+  struct libusb_transfer *status_xfer;
+  uint8_t status_buf[32];
+  /** Function to call when we receive status updates from the camera */
+  uvc_status_callback_t *status_cb;
+  void *status_user_ptr;
+  /** Function to call when we receive button events from the camera */
+  uvc_button_callback_t *button_cb;
+  void *button_user_ptr;
+
+  uvc_stream_handle_t *streams;
+  /** Whether the camera is an iSight that sends one header per frame */
+  uint8_t is_isight;
+  uint32_t claimed;
+
+  /* Per-machine altsetting override set with uvc_set_altsetting_override().
+   * Zero-initialised by the calloc() in uvc_open_internal, so an untouched
+   * handle falls through to the compile-time quirks table in stream.c. */
+  uint8_t altsetting_override_valid;
+  uint8_t altsetting_override_altsetting;
+  uint16_t altsetting_override_payload;
+};
+
+/** Context within which we communicate with devices */
+struct uvc_context {
+  /** Underlying context for USB communication */
+  struct libusb_context *usb_ctx;
+  /** True iff libuvc initialized the underlying USB context */
+  uint8_t own_usb_ctx;
+  /** List of open devices in this context */
+  uvc_device_handle_t *open_devices;
+  pthread_t handler_thread;
+  int kill_handler_thread;
+};
+
+uvc_error_t uvc_query_stream_ctrl(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    uint8_t probe,
+    enum uvc_req_code req);
+
+void uvc_start_handler_thread(uvc_context_t *ctx);
+uvc_error_t uvc_claim_if(uvc_device_handle_t *devh, int idx);
+uvc_error_t uvc_release_if(uvc_device_handle_t *devh, int idx);
+
+#endif // !def(LIBUVC_INTERNAL_H)
+/** @endcond */

collector/core/gripper/camera_service_src/third_party/libuvc/include/utlist.h

@@ -0,0 +1,490 @@
+/*
+Copyright (c) 2007-2010, Troy D. Hanson   http://uthash.sourceforge.net
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef UTLIST_H
+#define UTLIST_H
+
+#define UTLIST_VERSION 1.9.1
+
+/* 
+ * This file contains macros to manipulate singly and doubly-linked lists.
+ *
+ * 1. LL_ macros:  singly-linked lists.
+ * 2. DL_ macros:  doubly-linked lists.
+ * 3. CDL_ macros: circular doubly-linked lists.
+ *
+ * To use singly-linked lists, your structure must have a "next" pointer.
+ * To use doubly-linked lists, your structure must "prev" and "next" pointers.
+ * Either way, the pointer to the head of the list must be initialized to NULL.
+ * 
+ * ----------------.EXAMPLE -------------------------
+ * struct item {
+ *      int id;
+ *      struct item *prev, *next;
+ * }
+ *
+ * struct item *list = NULL:
+ *
+ * int main() {
+ *      struct item *item;
+ *      ... allocate and populate item ...
+ *      DL_APPEND(list, item);
+ * }
+ * --------------------------------------------------
+ *
+ * For doubly-linked lists, the append and delete macros are O(1)
+ * For singly-linked lists, append and delete are O(n) but prepend is O(1)
+ * The sort macro is O(n log(n)) for all types of single/double/circular lists.
+ */
+
+/* These macros use decltype or the earlier __typeof GNU extension.
+   As decltype is only available in newer compilers (VS2010 or gcc 4.3+
+   when compiling c++ code), this code uses whatever method is needed
+   or, for VS2008 where neither is available, uses casting workarounds. */
+#ifdef _MSC_VER            /* MS compiler */
+#if _MSC_VER >= 1600 && defined(__cplusplus)  /* VS2010 or newer in C++ mode */
+#define LDECLTYPE(x) decltype(x)
+#else                     /* VS2008 or older (or VS2010 in C mode) */
+#define NO_DECLTYPE
+#define LDECLTYPE(x) char*
+#endif
+#else                      /* GNU, Sun and other compilers */
+#define LDECLTYPE(x) __typeof(x)
+#endif
+
+/* for VS2008 we use some workarounds to get around the lack of decltype,
+ * namely, we always reassign our tmp variable to the list head if we need
+ * to dereference its prev/next pointers, and save/restore the real head.*/
+#ifdef NO_DECLTYPE
+#define _SV(elt,list) _tmp = (char*)(list); {char **_alias = (char**)&(list); *_alias = (elt); }
+#define _NEXT(elt,list) ((char*)((list)->next))
+#define _NEXTASGN(elt,list,to) { char **_alias = (char**)&((list)->next); *_alias=(char*)(to); }
+#define _PREV(elt,list) ((char*)((list)->prev))
+#define _PREVASGN(elt,list,to) { char **_alias = (char**)&((list)->prev); *_alias=(char*)(to); }
+#define _RS(list) { char **_alias = (char**)&(list); *_alias=_tmp; }
+#define _CASTASGN(a,b) { char **_alias = (char**)&(a); *_alias=(char*)(b); }
+#else 
+#define _SV(elt,list)
+#define _NEXT(elt,list) ((elt)->next)
+#define _NEXTASGN(elt,list,to) ((elt)->next)=(to)
+#define _PREV(elt,list) ((elt)->prev)
+#define _PREVASGN(elt,list,to) ((elt)->prev)=(to)
+#define _RS(list)
+#define _CASTASGN(a,b) (a)=(b)
+#endif
+
+/******************************************************************************
+ * The sort macro is an adaptation of Simon Tatham's O(n log(n)) mergesort    *
+ * Unwieldy variable names used here to avoid shadowing passed-in variables.  *
+ *****************************************************************************/
+#define LL_SORT(list, cmp)                                                                     \
+do {                                                                                           \
+  LDECLTYPE(list) _ls_p;                                                                       \
+  LDECLTYPE(list) _ls_q;                                                                       \
+  LDECLTYPE(list) _ls_e;                                                                       \
+  LDECLTYPE(list) _ls_tail;                                                                    \
+  LDECLTYPE(list) _ls_oldhead;                                                                 \
+  LDECLTYPE(list) _tmp;                                                                        \
+  int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping;                       \
+  if (list) {                                                                                  \
+    _ls_insize = 1;                                                                            \
+    _ls_looping = 1;                                                                           \
+    while (_ls_looping) {                                                                      \
+      _CASTASGN(_ls_p,list);                                                                   \
+      _CASTASGN(_ls_oldhead,list);                                                             \
+      list = NULL;                                                                             \
+      _ls_tail = NULL;                                                                         \
+      _ls_nmerges = 0;                                                                         \
+      while (_ls_p) {                                                                          \
+        _ls_nmerges++;                                                                         \
+        _ls_q = _ls_p;                                                                         \
+        _ls_psize = 0;                                                                         \
+        for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {                                         \
+          _ls_psize++;                                                                         \
+          _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list);                               \
+          if (!_ls_q) break;                                                                   \
+        }                                                                                      \
+        _ls_qsize = _ls_insize;                                                                \
+        while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) {                                    \
+          if (_ls_psize == 0) {                                                                \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+          } else if (_ls_qsize == 0 || !_ls_q) {                                               \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+          } else if (cmp(_ls_p,_ls_q) <= 0) {                                                  \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+          } else {                                                                             \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+          }                                                                                    \
+          if (_ls_tail) {                                                                      \
+            _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e); _RS(list);                     \
+          } else {                                                                             \
+            _CASTASGN(list,_ls_e);                                                             \
+          }                                                                                    \
+          _ls_tail = _ls_e;                                                                    \
+        }                                                                                      \
+        _ls_p = _ls_q;                                                                         \
+      }                                                                                        \
+      _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL); _RS(list);                            \
+      if (_ls_nmerges <= 1) {                                                                  \
+        _ls_looping=0;                                                                         \
+      }                                                                                        \
+      _ls_insize *= 2;                                                                         \
+    }                                                                                          \
+  } else _tmp=NULL; /* quiet gcc unused variable warning */                                    \
+} while (0)
+
+#define DL_SORT(list, cmp)                                                                     \
+do {                                                                                           \
+  LDECLTYPE(list) _ls_p;                                                                       \
+  LDECLTYPE(list) _ls_q;                                                                       \
+  LDECLTYPE(list) _ls_e;                                                                       \
+  LDECLTYPE(list) _ls_tail;                                                                    \
+  LDECLTYPE(list) _ls_oldhead;                                                                 \
+  LDECLTYPE(list) _tmp;                                                                        \
+  int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping;                       \
+  if (list) {                                                                                  \
+    _ls_insize = 1;                                                                            \
+    _ls_looping = 1;                                                                           \
+    while (_ls_looping) {                                                                      \
+      _CASTASGN(_ls_p,list);                                                                   \
+      _CASTASGN(_ls_oldhead,list);                                                             \
+      list = NULL;                                                                             \
+      _ls_tail = NULL;                                                                         \
+      _ls_nmerges = 0;                                                                         \
+      while (_ls_p) {                                                                          \
+        _ls_nmerges++;                                                                         \
+        _ls_q = _ls_p;                                                                         \
+        _ls_psize = 0;                                                                         \
+        for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {                                         \
+          _ls_psize++;                                                                         \
+          _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list);                               \
+          if (!_ls_q) break;                                                                   \
+        }                                                                                      \
+        _ls_qsize = _ls_insize;                                                                \
+        while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) {                                    \
+          if (_ls_psize == 0) {                                                                \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+          } else if (_ls_qsize == 0 || !_ls_q) {                                               \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+          } else if (cmp(_ls_p,_ls_q) <= 0) {                                                  \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+          } else {                                                                             \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+          }                                                                                    \
+          if (_ls_tail) {                                                                      \
+            _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e); _RS(list);                     \
+          } else {                                                                             \
+            _CASTASGN(list,_ls_e);                                                             \
+          }                                                                                    \
+          _SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail); _RS(list);                          \
+          _ls_tail = _ls_e;                                                                    \
+        }                                                                                      \
+        _ls_p = _ls_q;                                                                         \
+      }                                                                                        \
+      _CASTASGN(list->prev, _ls_tail);                                                         \
+      _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL); _RS(list);                            \
+      if (_ls_nmerges <= 1) {                                                                  \
+        _ls_looping=0;                                                                         \
+      }                                                                                        \
+      _ls_insize *= 2;                                                                         \
+    }                                                                                          \
+  } else _tmp=NULL; /* quiet gcc unused variable warning */                                    \
+} while (0)
+
+#define CDL_SORT(list, cmp)                                                                    \
+do {                                                                                           \
+  LDECLTYPE(list) _ls_p;                                                                       \
+  LDECLTYPE(list) _ls_q;                                                                       \
+  LDECLTYPE(list) _ls_e;                                                                       \
+  LDECLTYPE(list) _ls_tail;                                                                    \
+  LDECLTYPE(list) _ls_oldhead;                                                                 \
+  LDECLTYPE(list) _tmp;                                                                        \
+  LDECLTYPE(list) _tmp2;                                                                       \
+  int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping;                       \
+  if (list) {                                                                                  \
+    _ls_insize = 1;                                                                            \
+    _ls_looping = 1;                                                                           \
+    while (_ls_looping) {                                                                      \
+      _CASTASGN(_ls_p,list);                                                                   \
+      _CASTASGN(_ls_oldhead,list);                                                             \
+      list = NULL;                                                                             \
+      _ls_tail = NULL;                                                                         \
+      _ls_nmerges = 0;                                                                         \
+      while (_ls_p) {                                                                          \
+        _ls_nmerges++;                                                                         \
+        _ls_q = _ls_p;                                                                         \
+        _ls_psize = 0;                                                                         \
+        for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) {                                         \
+          _ls_psize++;                                                                         \
+          _SV(_ls_q,list);                                                                     \
+          if (_NEXT(_ls_q,list) == _ls_oldhead) {                                              \
+            _ls_q = NULL;                                                                      \
+          } else {                                                                             \
+            _ls_q = _NEXT(_ls_q,list);                                                         \
+          }                                                                                    \
+          _RS(list);                                                                           \
+          if (!_ls_q) break;                                                                   \
+        }                                                                                      \
+        _ls_qsize = _ls_insize;                                                                \
+        while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) {                                    \
+          if (_ls_psize == 0) {                                                                \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+            if (_ls_q == _ls_oldhead) { _ls_q = NULL; }                                        \
+          } else if (_ls_qsize == 0 || !_ls_q) {                                               \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+            if (_ls_p == _ls_oldhead) { _ls_p = NULL; }                                        \
+          } else if (cmp(_ls_p,_ls_q) <= 0) {                                                  \
+            _ls_e = _ls_p; _SV(_ls_p,list); _ls_p = _NEXT(_ls_p,list); _RS(list); _ls_psize--; \
+            if (_ls_p == _ls_oldhead) { _ls_p = NULL; }                                        \
+          } else {                                                                             \
+            _ls_e = _ls_q; _SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list); _RS(list); _ls_qsize--; \
+            if (_ls_q == _ls_oldhead) { _ls_q = NULL; }                                        \
+          }                                                                                    \
+          if (_ls_tail) {                                                                      \
+            _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e); _RS(list);                     \
+          } else {                                                                             \
+            _CASTASGN(list,_ls_e);                                                             \
+          }                                                                                    \
+          _SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail); _RS(list);                          \
+          _ls_tail = _ls_e;                                                                    \
+        }                                                                                      \
+        _ls_p = _ls_q;                                                                         \
+      }                                                                                        \
+      _CASTASGN(list->prev,_ls_tail);                                                          \
+      _CASTASGN(_tmp2,list);                                                                   \
+      _SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_tmp2); _RS(list);                           \
+      if (_ls_nmerges <= 1) {                                                                  \
+        _ls_looping=0;                                                                         \
+      }                                                                                        \
+      _ls_insize *= 2;                                                                         \
+    }                                                                                          \
+  } else _tmp=NULL; /* quiet gcc unused variable warning */                                    \
+} while (0)
+
+/******************************************************************************
+ * singly linked list macros (non-circular)                                   *
+ *****************************************************************************/
+#define LL_PREPEND(head,add)                                                                   \
+do {                                                                                           \
+  (add)->next = head;                                                                          \
+  head = add;                                                                                  \
+} while (0)
+
+#define LL_APPEND(head,add)                                                                    \
+do {                                                                                           \
+  LDECLTYPE(head) _tmp;                                                                        \
+  (add)->next=NULL;                                                                            \
+  if (head) {                                                                                  \
+    _tmp = head;                                                                               \
+    while (_tmp->next) { _tmp = _tmp->next; }                                                  \
+    _tmp->next=(add);                                                                          \
+  } else {                                                                                     \
+    (head)=(add);                                                                              \
+  }                                                                                            \
+} while (0)
+
+#define LL_DELETE(head,del)                                                                    \
+do {                                                                                           \
+  LDECLTYPE(head) _tmp;                                                                        \
+  if ((head) == (del)) {                                                                       \
+    (head)=(head)->next;                                                                       \
+  } else {                                                                                     \
+    _tmp = head;                                                                               \
+    while (_tmp->next && (_tmp->next != (del))) {                                              \
+      _tmp = _tmp->next;                                                                       \
+    }                                                                                          \
+    if (_tmp->next) {                                                                          \
+      _tmp->next = ((del)->next);                                                              \
+    }                                                                                          \
+  }                                                                                            \
+} while (0)
+
+/* Here are VS2008 replacements for LL_APPEND and LL_DELETE */
+#define LL_APPEND_VS2008(head,add)                                                             \
+do {                                                                                           \
+  if (head) {                                                                                  \
+    (add)->next = head;     /* use add->next as a temp variable */                             \
+    while ((add)->next->next) { (add)->next = (add)->next->next; }                             \
+    (add)->next->next=(add);                                                                   \
+  } else {                                                                                     \
+    (head)=(add);                                                                              \
+  }                                                                                            \
+  (add)->next=NULL;                                                                            \
+} while (0)
+
+#define LL_DELETE_VS2008(head,del)                                                             \
+do {                                                                                           \
+  if ((head) == (del)) {                                                                       \
+    (head)=(head)->next;                                                                       \
+  } else {                                                                                     \
+    char *_tmp = (char*)(head);                                                                \
+    while (head->next && (head->next != (del))) {                                              \
+      head = head->next;                                                                       \
+    }                                                                                          \
+    if (head->next) {                                                                          \
+      head->next = ((del)->next);                                                              \
+    }                                                                                          \
+    {                                                                                          \
+      char **_head_alias = (char**)&(head);                                                    \
+      *_head_alias = _tmp;                                                                     \
+    }                                                                                          \
+  }                                                                                            \
+} while (0)
+#ifdef NO_DECLTYPE
+#undef LL_APPEND
+#define LL_APPEND LL_APPEND_VS2008
+#undef LL_DELETE
+#define LL_DELETE LL_DELETE_VS2008
+#endif
+/* end VS2008 replacements */
+
+#define LL_FOREACH(head,el)                                                                    \
+    for(el=head;el;el=el->next)
+
+#define LL_FOREACH_SAFE(head,el,tmp)                                                           \
+  for((el)=(head);(el) && (tmp = (el)->next, 1); (el) = tmp)
+
+#define LL_SEARCH_SCALAR(head,out,field,val)                                                   \
+do {                                                                                           \
+    LL_FOREACH(head,out) {                                                                     \
+      if ((out)->field == (val)) break;                                                        \
+    }                                                                                          \
+} while(0) 
+
+#define LL_SEARCH(head,out,elt,cmp)                                                            \
+do {                                                                                           \
+    LL_FOREACH(head,out) {                                                                     \
+      if ((cmp(out,elt))==0) break;                                                            \
+    }                                                                                          \
+} while(0) 
+
+/******************************************************************************
+ * doubly linked list macros (non-circular)                                   *
+ *****************************************************************************/
+#define DL_PREPEND(head,add)                                                                   \
+do {                                                                                           \
+ (add)->next = head;                                                                           \
+ if (head) {                                                                                   \
+   (add)->prev = (head)->prev;                                                                 \
+   (head)->prev = (add);                                                                       \
+ } else {                                                                                      \
+   (add)->prev = (add);                                                                        \
+ }                                                                                             \
+ (head) = (add);                                                                               \
+} while (0)
+
+#define DL_APPEND(head,add)                                                                    \
+do {                                                                                           \
+  if (head) {                                                                                  \
+      (add)->prev = (head)->prev;                                                              \
+      (head)->prev->next = (add);                                                              \
+      (head)->prev = (add);                                                                    \
+      (add)->next = NULL;                                                                      \
+  } else {                                                                                     \
+      (head)=(add);                                                                            \
+      (head)->prev = (head);                                                                   \
+      (head)->next = NULL;                                                                     \
+  }                                                                                            \
+} while (0);
+
+#define DL_DELETE(head,del)                                                                    \
+do {                                                                                           \
+  if ((del)->prev == (del)) {                                                                  \
+      (head)=NULL;                                                                             \
+  } else if ((del)==(head)) {                                                                  \
+      (del)->next->prev = (del)->prev;                                                         \
+      (head) = (del)->next;                                                                    \
+  } else {                                                                                     \
+      (del)->prev->next = (del)->next;                                                         \
+      if ((del)->next) {                                                                       \
+          (del)->next->prev = (del)->prev;                                                     \
+      } else {                                                                                 \
+          (head)->prev = (del)->prev;                                                          \
+      }                                                                                        \
+  }                                                                                            \
+} while (0);
+
+
+#define DL_FOREACH(head,el)                                                                    \
+    for(el=head;el;el=el->next)
+
+/* this version is safe for deleting the elements during iteration */
+#define DL_FOREACH_SAFE(head,el,tmp)                                                           \
+  for((el)=(head);(el) && (tmp = (el)->next, 1); (el) = tmp)
+
+/* these are identical to their singly-linked list counterparts */
+#define DL_SEARCH_SCALAR LL_SEARCH_SCALAR
+#define DL_SEARCH LL_SEARCH
+
+/******************************************************************************
+ * circular doubly linked list macros                                         *
+ *****************************************************************************/
+#define CDL_PREPEND(head,add)                                                                  \
+do {                                                                                           \
+ if (head) {                                                                                   \
+   (add)->prev = (head)->prev;                                                                 \
+   (add)->next = (head);                                                                       \
+   (head)->prev = (add);                                                                       \
+   (add)->prev->next = (add);                                                                  \
+ } else {                                                                                      \
+   (add)->prev = (add);                                                                        \
+   (add)->next = (add);                                                                        \
+ }                                                                                             \
+(head)=(add);                                                                                  \
+} while (0)
+
+#define CDL_DELETE(head,del)                                                                   \
+do {                                                                                           \
+  if ( ((head)==(del)) && ((head)->next == (head))) {                                          \
+      (head) = 0L;                                                                             \
+  } else {                                                                                     \
+     (del)->next->prev = (del)->prev;                                                          \
+     (del)->prev->next = (del)->next;                                                          \
+     if ((del) == (head)) (head)=(del)->next;                                                  \
+  }                                                                                            \
+} while (0);
+
+#define CDL_FOREACH(head,el)                                                                   \
+    for(el=head;el;el=(el->next==head ? 0L : el->next)) 
+
+#define CDL_FOREACH_SAFE(head,el,tmp1,tmp2)                                                    \
+  for((el)=(head), ((tmp1)=(head)?((head)->prev):NULL);                                        \
+      (el) && ((tmp2)=(el)->next, 1);                                                          \
+      ((el) = (((el)==(tmp1)) ? 0L : (tmp2))))
+
+#define CDL_SEARCH_SCALAR(head,out,field,val)                                                  \
+do {                                                                                           \
+    CDL_FOREACH(head,out) {                                                                    \
+      if ((out)->field == (val)) break;                                                        \
+    }                                                                                          \
+} while(0) 
+
+#define CDL_SEARCH(head,out,elt,cmp)                                                           \
+do {                                                                                           \
+    CDL_FOREACH(head,out) {                                                                    \
+      if ((cmp(out,elt))==0) break;                                                            \
+    }                                                                                          \
+} while(0) 
+
+#endif /* UTLIST_H */
+

collector/core/gripper/camera_service_src/third_party/libuvc/libuvc.pc.in

@@ -0,0 +1,11 @@
+libdir=@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@
+includedir=@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_INCLUDEDIR@
+
+Name: libuvc
+Description: @libuvc_DESCRIPTION@
+URL: @libuvc_URL@
+Version: @libuvc_VERSION@
+Libs: -L${libdir} -luvc
+Libs.private: -lusb-1.0 @PKGCONFIG_JPEG_LDFLAG@
+Cflags: -I${includedir}
+Requires: libusb-1.0

collector/core/gripper/camera_service_src/third_party/libuvc/libuvcConfig.cmake

@@ -0,0 +1,17 @@
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
+
+# If find_package called with REQUIRED or QUIET we need to
+# forward down it
+unset(extraArgs)
+if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+  list(APPEND extraArgs QUIET)
+endif()
+if(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED)
+  list(APPEND extraArgs REQUIRED)
+endif()
+
+find_package(JpegPkg ${extraArgs})
+find_package(LibUSB ${extraArgs})
+include("${CMAKE_CURRENT_LIST_DIR}/libuvcTargets.cmake")
+
+set(libuvc_FOUND TRUE)

collector/core/gripper/camera_service_src/third_party/libuvc/src/ctrl-gen.c

@@ -0,0 +1,2259 @@
+/* This is an AUTO-GENERATED file! Update it with the output of `ctrl-gen.py def`. */
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+static const int REQ_TYPE_SET = 0x21;
+static const int REQ_TYPE_GET = 0xa1;
+
+/** @ingroup ctrl
+ * @brief Reads the SCANNING_MODE control.
+ * @param devh UVC device handle
+ * @param[out] mode 0: interlaced, 1: progressive
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_scanning_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_SCANNING_MODE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *mode = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the SCANNING_MODE control.
+ * @param devh UVC device handle
+ * @param mode 0: interlaced, 1: progressive
+ */
+uvc_error_t uvc_set_scanning_mode(uvc_device_handle_t *devh, uint8_t mode) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = mode;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_SCANNING_MODE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads camera's auto-exposure mode.
+ * 
+ * See uvc_set_ae_mode() for a description of the available modes.
+ * @param devh UVC device handle
+ * @param[out] mode 1: manual mode; 2: auto mode; 4: shutter priority mode; 8: aperture priority mode
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_ae_mode(uvc_device_handle_t *devh, uint8_t* mode, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_AE_MODE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *mode = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets camera's auto-exposure mode.
+ * 
+ * Cameras may support any of the following AE modes:
+ *  * UVC_AUTO_EXPOSURE_MODE_MANUAL (1) - manual exposure time, manual iris
+ *  * UVC_AUTO_EXPOSURE_MODE_AUTO (2) - auto exposure time, auto iris
+ *  * UVC_AUTO_EXPOSURE_MODE_SHUTTER_PRIORITY (4) - manual exposure time, auto iris
+ *  * UVC_AUTO_EXPOSURE_MODE_APERTURE_PRIORITY (8) - auto exposure time, manual iris
+ * 
+ * Most cameras provide manual mode and aperture priority mode.
+ * @param devh UVC device handle
+ * @param mode 1: manual mode; 2: auto mode; 4: shutter priority mode; 8: aperture priority mode
+ */
+uvc_error_t uvc_set_ae_mode(uvc_device_handle_t *devh, uint8_t mode) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = mode;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_AE_MODE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Checks whether the camera may vary the frame rate for exposure control reasons.
+ * See uvc_set_ae_priority() for a description of the `priority` field.
+ * @param devh UVC device handle
+ * @param[out] priority 0: frame rate must remain constant; 1: frame rate may be varied for AE purposes
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_ae_priority(uvc_device_handle_t *devh, uint8_t* priority, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_AE_PRIORITY_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *priority = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Chooses whether the camera may vary the frame rate for exposure control reasons.
+ * A `priority` value of zero means the camera may not vary its frame rate. A value of 1
+ * means the frame rate is variable. This setting has no effect outside of the `auto` and
+ * `shutter_priority` auto-exposure modes.
+ * @param devh UVC device handle
+ * @param priority 0: frame rate must remain constant; 1: frame rate may be varied for AE purposes
+ */
+uvc_error_t uvc_set_ae_priority(uvc_device_handle_t *devh, uint8_t priority) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = priority;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_AE_PRIORITY_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Gets the absolute exposure time.
+ * 
+ * See uvc_set_exposure_abs() for a description of the `time` field.
+ * @param devh UVC device handle
+ * @param[out] time 
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_exposure_abs(uvc_device_handle_t *devh, uint32_t* time, enum uvc_req_code req_code) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *time = DW_TO_INT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the absolute exposure time.
+ * 
+ * The `time` parameter should be provided in units of 0.0001 seconds (e.g., use the value 100
+ * for a 10ms exposure period). Auto exposure should be set to `manual` or `shutter_priority`
+ * before attempting to change this setting.
+ * @param devh UVC device handle
+ * @param time 
+ */
+uvc_error_t uvc_set_exposure_abs(uvc_device_handle_t *devh, uint32_t time) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  INT_TO_DW(time, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the exposure time relative to the current setting.
+ * @param devh UVC device handle
+ * @param[out] step number of steps by which to change the exposure time, or zero to set the default exposure time
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_exposure_rel(uvc_device_handle_t *devh, int8_t* step, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *step = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the exposure time relative to the current setting.
+ * @param devh UVC device handle
+ * @param step number of steps by which to change the exposure time, or zero to set the default exposure time
+ */
+uvc_error_t uvc_set_exposure_rel(uvc_device_handle_t *devh, int8_t step) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = step;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the distance at which an object is optimally focused.
+ * @param devh UVC device handle
+ * @param[out] focus focal target distance in millimeters
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_focus_abs(uvc_device_handle_t *devh, uint16_t* focus, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_FOCUS_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *focus = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the distance at which an object is optimally focused.
+ * @param devh UVC device handle
+ * @param focus focal target distance in millimeters
+ */
+uvc_error_t uvc_set_focus_abs(uvc_device_handle_t *devh, uint16_t focus) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(focus, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_FOCUS_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the FOCUS_RELATIVE control.
+ * @param devh UVC device handle
+ * @param[out] focus_rel TODO
+ * @param[out] speed TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_focus_rel(uvc_device_handle_t *devh, int8_t* focus_rel, uint8_t* speed, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_FOCUS_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *focus_rel = data[0];
+    *speed = data[1];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the FOCUS_RELATIVE control.
+ * @param devh UVC device handle
+ * @param focus_rel TODO
+ * @param speed TODO
+ */
+uvc_error_t uvc_set_focus_rel(uvc_device_handle_t *devh, int8_t focus_rel, uint8_t speed) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  data[0] = focus_rel;
+  data[1] = speed;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_FOCUS_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the FOCUS_SIMPLE control.
+ * @param devh UVC device handle
+ * @param[out] focus TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_focus_simple_range(uvc_device_handle_t *devh, uint8_t* focus, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_FOCUS_SIMPLE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *focus = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the FOCUS_SIMPLE control.
+ * @param devh UVC device handle
+ * @param focus TODO
+ */
+uvc_error_t uvc_set_focus_simple_range(uvc_device_handle_t *devh, uint8_t focus) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = focus;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_FOCUS_SIMPLE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the FOCUS_AUTO control.
+ * @param devh UVC device handle
+ * @param[out] state TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_focus_auto(uvc_device_handle_t *devh, uint8_t* state, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_FOCUS_AUTO_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *state = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the FOCUS_AUTO control.
+ * @param devh UVC device handle
+ * @param state TODO
+ */
+uvc_error_t uvc_set_focus_auto(uvc_device_handle_t *devh, uint8_t state) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = state;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_FOCUS_AUTO_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the IRIS_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param[out] iris TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_iris_abs(uvc_device_handle_t *devh, uint16_t* iris, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_IRIS_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *iris = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the IRIS_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param iris TODO
+ */
+uvc_error_t uvc_set_iris_abs(uvc_device_handle_t *devh, uint16_t iris) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(iris, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_IRIS_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the IRIS_RELATIVE control.
+ * @param devh UVC device handle
+ * @param[out] iris_rel TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_iris_rel(uvc_device_handle_t *devh, uint8_t* iris_rel, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_IRIS_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *iris_rel = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the IRIS_RELATIVE control.
+ * @param devh UVC device handle
+ * @param iris_rel TODO
+ */
+uvc_error_t uvc_set_iris_rel(uvc_device_handle_t *devh, uint8_t iris_rel) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = iris_rel;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_IRIS_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ZOOM_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param[out] focal_length TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_zoom_abs(uvc_device_handle_t *devh, uint16_t* focal_length, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_ZOOM_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *focal_length = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ZOOM_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param focal_length TODO
+ */
+uvc_error_t uvc_set_zoom_abs(uvc_device_handle_t *devh, uint16_t focal_length) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(focal_length, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_ZOOM_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ZOOM_RELATIVE control.
+ * @param devh UVC device handle
+ * @param[out] zoom_rel TODO
+ * @param[out] digital_zoom TODO
+ * @param[out] speed TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_zoom_rel(uvc_device_handle_t *devh, int8_t* zoom_rel, uint8_t* digital_zoom, uint8_t* speed, enum uvc_req_code req_code) {
+  uint8_t data[3];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_ZOOM_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *zoom_rel = data[0];
+    *digital_zoom = data[1];
+    *speed = data[2];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ZOOM_RELATIVE control.
+ * @param devh UVC device handle
+ * @param zoom_rel TODO
+ * @param digital_zoom TODO
+ * @param speed TODO
+ */
+uvc_error_t uvc_set_zoom_rel(uvc_device_handle_t *devh, int8_t zoom_rel, uint8_t digital_zoom, uint8_t speed) {
+  uint8_t data[3];
+  uvc_error_t ret;
+
+  data[0] = zoom_rel;
+  data[1] = digital_zoom;
+  data[2] = speed;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_ZOOM_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the PANTILT_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param[out] pan TODO
+ * @param[out] tilt TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_pantilt_abs(uvc_device_handle_t *devh, int32_t* pan, int32_t* tilt, enum uvc_req_code req_code) {
+  uint8_t data[8];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_PANTILT_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *pan = DW_TO_INT(data + 0);
+    *tilt = DW_TO_INT(data + 4);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the PANTILT_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param pan TODO
+ * @param tilt TODO
+ */
+uvc_error_t uvc_set_pantilt_abs(uvc_device_handle_t *devh, int32_t pan, int32_t tilt) {
+  uint8_t data[8];
+  uvc_error_t ret;
+
+  INT_TO_DW(pan, data + 0);
+  INT_TO_DW(tilt, data + 4);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_PANTILT_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the PANTILT_RELATIVE control.
+ * @param devh UVC device handle
+ * @param[out] pan_rel TODO
+ * @param[out] pan_speed TODO
+ * @param[out] tilt_rel TODO
+ * @param[out] tilt_speed TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_pantilt_rel(uvc_device_handle_t *devh, int8_t* pan_rel, uint8_t* pan_speed, int8_t* tilt_rel, uint8_t* tilt_speed, enum uvc_req_code req_code) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_PANTILT_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *pan_rel = data[0];
+    *pan_speed = data[1];
+    *tilt_rel = data[2];
+    *tilt_speed = data[3];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the PANTILT_RELATIVE control.
+ * @param devh UVC device handle
+ * @param pan_rel TODO
+ * @param pan_speed TODO
+ * @param tilt_rel TODO
+ * @param tilt_speed TODO
+ */
+uvc_error_t uvc_set_pantilt_rel(uvc_device_handle_t *devh, int8_t pan_rel, uint8_t pan_speed, int8_t tilt_rel, uint8_t tilt_speed) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  data[0] = pan_rel;
+  data[1] = pan_speed;
+  data[2] = tilt_rel;
+  data[3] = tilt_speed;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_PANTILT_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ROLL_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param[out] roll TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_roll_abs(uvc_device_handle_t *devh, int16_t* roll, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_ROLL_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *roll = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ROLL_ABSOLUTE control.
+ * @param devh UVC device handle
+ * @param roll TODO
+ */
+uvc_error_t uvc_set_roll_abs(uvc_device_handle_t *devh, int16_t roll) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(roll, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_ROLL_ABSOLUTE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ROLL_RELATIVE control.
+ * @param devh UVC device handle
+ * @param[out] roll_rel TODO
+ * @param[out] speed TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_roll_rel(uvc_device_handle_t *devh, int8_t* roll_rel, uint8_t* speed, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_ROLL_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *roll_rel = data[0];
+    *speed = data[1];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ROLL_RELATIVE control.
+ * @param devh UVC device handle
+ * @param roll_rel TODO
+ * @param speed TODO
+ */
+uvc_error_t uvc_set_roll_rel(uvc_device_handle_t *devh, int8_t roll_rel, uint8_t speed) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  data[0] = roll_rel;
+  data[1] = speed;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_ROLL_RELATIVE_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the PRIVACY control.
+ * @param devh UVC device handle
+ * @param[out] privacy TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_privacy(uvc_device_handle_t *devh, uint8_t* privacy, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_PRIVACY_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *privacy = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the PRIVACY control.
+ * @param devh UVC device handle
+ * @param privacy TODO
+ */
+uvc_error_t uvc_set_privacy(uvc_device_handle_t *devh, uint8_t privacy) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = privacy;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_PRIVACY_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the DIGITAL_WINDOW control.
+ * @param devh UVC device handle
+ * @param[out] window_top TODO
+ * @param[out] window_left TODO
+ * @param[out] window_bottom TODO
+ * @param[out] window_right TODO
+ * @param[out] num_steps TODO
+ * @param[out] num_steps_units TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_digital_window(uvc_device_handle_t *devh, uint16_t* window_top, uint16_t* window_left, uint16_t* window_bottom, uint16_t* window_right, uint16_t* num_steps, uint16_t* num_steps_units, enum uvc_req_code req_code) {
+  uint8_t data[12];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_DIGITAL_WINDOW_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *window_top = SW_TO_SHORT(data + 0);
+    *window_left = SW_TO_SHORT(data + 2);
+    *window_bottom = SW_TO_SHORT(data + 4);
+    *window_right = SW_TO_SHORT(data + 6);
+    *num_steps = SW_TO_SHORT(data + 8);
+    *num_steps_units = SW_TO_SHORT(data + 10);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the DIGITAL_WINDOW control.
+ * @param devh UVC device handle
+ * @param window_top TODO
+ * @param window_left TODO
+ * @param window_bottom TODO
+ * @param window_right TODO
+ * @param num_steps TODO
+ * @param num_steps_units TODO
+ */
+uvc_error_t uvc_set_digital_window(uvc_device_handle_t *devh, uint16_t window_top, uint16_t window_left, uint16_t window_bottom, uint16_t window_right, uint16_t num_steps, uint16_t num_steps_units) {
+  uint8_t data[12];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(window_top, data + 0);
+  SHORT_TO_SW(window_left, data + 2);
+  SHORT_TO_SW(window_bottom, data + 4);
+  SHORT_TO_SW(window_right, data + 6);
+  SHORT_TO_SW(num_steps, data + 8);
+  SHORT_TO_SW(num_steps_units, data + 10);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_DIGITAL_WINDOW_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the REGION_OF_INTEREST control.
+ * @param devh UVC device handle
+ * @param[out] roi_top TODO
+ * @param[out] roi_left TODO
+ * @param[out] roi_bottom TODO
+ * @param[out] roi_right TODO
+ * @param[out] auto_controls TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_digital_roi(uvc_device_handle_t *devh, uint16_t* roi_top, uint16_t* roi_left, uint16_t* roi_bottom, uint16_t* roi_right, uint16_t* auto_controls, enum uvc_req_code req_code) {
+  uint8_t data[10];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_CT_REGION_OF_INTEREST_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *roi_top = SW_TO_SHORT(data + 0);
+    *roi_left = SW_TO_SHORT(data + 2);
+    *roi_bottom = SW_TO_SHORT(data + 4);
+    *roi_right = SW_TO_SHORT(data + 6);
+    *auto_controls = SW_TO_SHORT(data + 8);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the REGION_OF_INTEREST control.
+ * @param devh UVC device handle
+ * @param roi_top TODO
+ * @param roi_left TODO
+ * @param roi_bottom TODO
+ * @param roi_right TODO
+ * @param auto_controls TODO
+ */
+uvc_error_t uvc_set_digital_roi(uvc_device_handle_t *devh, uint16_t roi_top, uint16_t roi_left, uint16_t roi_bottom, uint16_t roi_right, uint16_t auto_controls) {
+  uint8_t data[10];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(roi_top, data + 0);
+  SHORT_TO_SW(roi_left, data + 2);
+  SHORT_TO_SW(roi_bottom, data + 4);
+  SHORT_TO_SW(roi_right, data + 6);
+  SHORT_TO_SW(auto_controls, data + 8);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_CT_REGION_OF_INTEREST_CONTROL << 8,
+    uvc_get_camera_terminal(devh)->bTerminalID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the BACKLIGHT_COMPENSATION control.
+ * @param devh UVC device handle
+ * @param[out] backlight_compensation device-dependent backlight compensation mode; zero means backlight compensation is disabled
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_backlight_compensation(uvc_device_handle_t *devh, uint16_t* backlight_compensation, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_BACKLIGHT_COMPENSATION_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *backlight_compensation = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the BACKLIGHT_COMPENSATION control.
+ * @param devh UVC device handle
+ * @param backlight_compensation device-dependent backlight compensation mode; zero means backlight compensation is disabled
+ */
+uvc_error_t uvc_set_backlight_compensation(uvc_device_handle_t *devh, uint16_t backlight_compensation) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(backlight_compensation, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_BACKLIGHT_COMPENSATION_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the BRIGHTNESS control.
+ * @param devh UVC device handle
+ * @param[out] brightness TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_brightness(uvc_device_handle_t *devh, int16_t* brightness, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_BRIGHTNESS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *brightness = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the BRIGHTNESS control.
+ * @param devh UVC device handle
+ * @param brightness TODO
+ */
+uvc_error_t uvc_set_brightness(uvc_device_handle_t *devh, int16_t brightness) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(brightness, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_BRIGHTNESS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the CONTRAST control.
+ * @param devh UVC device handle
+ * @param[out] contrast TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_contrast(uvc_device_handle_t *devh, uint16_t* contrast, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_CONTRAST_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *contrast = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the CONTRAST control.
+ * @param devh UVC device handle
+ * @param contrast TODO
+ */
+uvc_error_t uvc_set_contrast(uvc_device_handle_t *devh, uint16_t contrast) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(contrast, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_CONTRAST_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the CONTRAST_AUTO control.
+ * @param devh UVC device handle
+ * @param[out] contrast_auto TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_contrast_auto(uvc_device_handle_t *devh, uint8_t* contrast_auto, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_CONTRAST_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *contrast_auto = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the CONTRAST_AUTO control.
+ * @param devh UVC device handle
+ * @param contrast_auto TODO
+ */
+uvc_error_t uvc_set_contrast_auto(uvc_device_handle_t *devh, uint8_t contrast_auto) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = contrast_auto;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_CONTRAST_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the GAIN control.
+ * @param devh UVC device handle
+ * @param[out] gain TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_gain(uvc_device_handle_t *devh, uint16_t* gain, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_GAIN_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *gain = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the GAIN control.
+ * @param devh UVC device handle
+ * @param gain TODO
+ */
+uvc_error_t uvc_set_gain(uvc_device_handle_t *devh, uint16_t gain) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(gain, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_GAIN_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the POWER_LINE_FREQUENCY control.
+ * @param devh UVC device handle
+ * @param[out] power_line_frequency TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_power_line_frequency(uvc_device_handle_t *devh, uint8_t* power_line_frequency, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_POWER_LINE_FREQUENCY_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *power_line_frequency = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the POWER_LINE_FREQUENCY control.
+ * @param devh UVC device handle
+ * @param power_line_frequency TODO
+ */
+uvc_error_t uvc_set_power_line_frequency(uvc_device_handle_t *devh, uint8_t power_line_frequency) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = power_line_frequency;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_POWER_LINE_FREQUENCY_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the HUE control.
+ * @param devh UVC device handle
+ * @param[out] hue TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_hue(uvc_device_handle_t *devh, int16_t* hue, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_HUE_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *hue = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the HUE control.
+ * @param devh UVC device handle
+ * @param hue TODO
+ */
+uvc_error_t uvc_set_hue(uvc_device_handle_t *devh, int16_t hue) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(hue, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_HUE_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the HUE_AUTO control.
+ * @param devh UVC device handle
+ * @param[out] hue_auto TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_hue_auto(uvc_device_handle_t *devh, uint8_t* hue_auto, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_HUE_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *hue_auto = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the HUE_AUTO control.
+ * @param devh UVC device handle
+ * @param hue_auto TODO
+ */
+uvc_error_t uvc_set_hue_auto(uvc_device_handle_t *devh, uint8_t hue_auto) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = hue_auto;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_HUE_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the SATURATION control.
+ * @param devh UVC device handle
+ * @param[out] saturation TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_saturation(uvc_device_handle_t *devh, uint16_t* saturation, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_SATURATION_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *saturation = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the SATURATION control.
+ * @param devh UVC device handle
+ * @param saturation TODO
+ */
+uvc_error_t uvc_set_saturation(uvc_device_handle_t *devh, uint16_t saturation) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(saturation, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_SATURATION_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the SHARPNESS control.
+ * @param devh UVC device handle
+ * @param[out] sharpness TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_sharpness(uvc_device_handle_t *devh, uint16_t* sharpness, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_SHARPNESS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *sharpness = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the SHARPNESS control.
+ * @param devh UVC device handle
+ * @param sharpness TODO
+ */
+uvc_error_t uvc_set_sharpness(uvc_device_handle_t *devh, uint16_t sharpness) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(sharpness, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_SHARPNESS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the GAMMA control.
+ * @param devh UVC device handle
+ * @param[out] gamma TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_gamma(uvc_device_handle_t *devh, uint16_t* gamma, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_GAMMA_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *gamma = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the GAMMA control.
+ * @param devh UVC device handle
+ * @param gamma TODO
+ */
+uvc_error_t uvc_set_gamma(uvc_device_handle_t *devh, uint16_t gamma) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(gamma, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_GAMMA_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the WHITE_BALANCE_TEMPERATURE control.
+ * @param devh UVC device handle
+ * @param[out] temperature TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_white_balance_temperature(uvc_device_handle_t *devh, uint16_t* temperature, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *temperature = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the WHITE_BALANCE_TEMPERATURE control.
+ * @param devh UVC device handle
+ * @param temperature TODO
+ */
+uvc_error_t uvc_set_white_balance_temperature(uvc_device_handle_t *devh, uint16_t temperature) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(temperature, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the WHITE_BALANCE_TEMPERATURE_AUTO control.
+ * @param devh UVC device handle
+ * @param[out] temperature_auto TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t* temperature_auto, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *temperature_auto = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the WHITE_BALANCE_TEMPERATURE_AUTO control.
+ * @param devh UVC device handle
+ * @param temperature_auto TODO
+ */
+uvc_error_t uvc_set_white_balance_temperature_auto(uvc_device_handle_t *devh, uint8_t temperature_auto) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = temperature_auto;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the WHITE_BALANCE_COMPONENT control.
+ * @param devh UVC device handle
+ * @param[out] blue TODO
+ * @param[out] red TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_white_balance_component(uvc_device_handle_t *devh, uint16_t* blue, uint16_t* red, enum uvc_req_code req_code) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *blue = SW_TO_SHORT(data + 0);
+    *red = SW_TO_SHORT(data + 2);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the WHITE_BALANCE_COMPONENT control.
+ * @param devh UVC device handle
+ * @param blue TODO
+ * @param red TODO
+ */
+uvc_error_t uvc_set_white_balance_component(uvc_device_handle_t *devh, uint16_t blue, uint16_t red) {
+  uint8_t data[4];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(blue, data + 0);
+  SHORT_TO_SW(red, data + 2);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the WHITE_BALANCE_COMPONENT_AUTO control.
+ * @param devh UVC device handle
+ * @param[out] white_balance_component_auto TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t* white_balance_component_auto, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *white_balance_component_auto = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the WHITE_BALANCE_COMPONENT_AUTO control.
+ * @param devh UVC device handle
+ * @param white_balance_component_auto TODO
+ */
+uvc_error_t uvc_set_white_balance_component_auto(uvc_device_handle_t *devh, uint8_t white_balance_component_auto) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = white_balance_component_auto;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the DIGITAL_MULTIPLIER control.
+ * @param devh UVC device handle
+ * @param[out] multiplier_step TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_digital_multiplier(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_DIGITAL_MULTIPLIER_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *multiplier_step = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the DIGITAL_MULTIPLIER control.
+ * @param devh UVC device handle
+ * @param multiplier_step TODO
+ */
+uvc_error_t uvc_set_digital_multiplier(uvc_device_handle_t *devh, uint16_t multiplier_step) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(multiplier_step, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_DIGITAL_MULTIPLIER_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the DIGITAL_MULTIPLIER_LIMIT control.
+ * @param devh UVC device handle
+ * @param[out] multiplier_step TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t* multiplier_step, enum uvc_req_code req_code) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *multiplier_step = SW_TO_SHORT(data + 0);
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the DIGITAL_MULTIPLIER_LIMIT control.
+ * @param devh UVC device handle
+ * @param multiplier_step TODO
+ */
+uvc_error_t uvc_set_digital_multiplier_limit(uvc_device_handle_t *devh, uint16_t multiplier_step) {
+  uint8_t data[2];
+  uvc_error_t ret;
+
+  SHORT_TO_SW(multiplier_step, data + 0);
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ANALOG_VIDEO_STANDARD control.
+ * @param devh UVC device handle
+ * @param[out] video_standard TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_analog_video_standard(uvc_device_handle_t *devh, uint8_t* video_standard, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *video_standard = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ANALOG_VIDEO_STANDARD control.
+ * @param devh UVC device handle
+ * @param video_standard TODO
+ */
+uvc_error_t uvc_set_analog_video_standard(uvc_device_handle_t *devh, uint8_t video_standard) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = video_standard;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the ANALOG_LOCK_STATUS control.
+ * @param devh UVC device handle
+ * @param[out] status TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t* status, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_PU_ANALOG_LOCK_STATUS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *status = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the ANALOG_LOCK_STATUS control.
+ * @param devh UVC device handle
+ * @param status TODO
+ */
+uvc_error_t uvc_set_analog_video_lock_status(uvc_device_handle_t *devh, uint8_t status) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = status;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_PU_ANALOG_LOCK_STATUS_CONTROL << 8,
+    uvc_get_processing_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @ingroup ctrl
+ * @brief Reads the INPUT_SELECT control.
+ * @param devh UVC device handle
+ * @param[out] selector TODO
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_input_select(uvc_device_handle_t *devh, uint8_t* selector, enum uvc_req_code req_code) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_SU_INPUT_SELECT_CONTROL << 8,
+    uvc_get_selector_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {
+    *selector = data[0];
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+
+/** @ingroup ctrl
+ * @brief Sets the INPUT_SELECT control.
+ * @param devh UVC device handle
+ * @param selector TODO
+ */
+uvc_error_t uvc_set_input_select(uvc_device_handle_t *devh, uint8_t selector) {
+  uint8_t data[1];
+  uvc_error_t ret;
+
+  data[0] = selector;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_SU_INPUT_SELECT_CONTROL << 8,
+    uvc_get_selector_units(devh)->bUnitID << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+

collector/core/gripper/camera_service_src/third_party/libuvc/src/ctrl-gen.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python
+from __future__ import print_function
+from collections import OrderedDict
+import getopt
+import sys
+import yaml
+
+class quoted(str): pass
+
+def quoted_presenter(dumper, data):
+    return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='"')
+yaml.add_representer(quoted, quoted_presenter)
+
+class literal(str): pass
+
+def literal_presenter(dumper, data):
+    return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
+yaml.add_representer(literal, literal_presenter)
+
+def ordered_dict_presenter(dumper, data):
+    return dumper.represent_dict(data.items())
+yaml.add_representer(OrderedDict, ordered_dict_presenter)
+
+def dict_constructor(loader, node):
+    return OrderedDict(loader.construct_pairs(node))
+_mapping_tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG
+yaml.add_constructor(_mapping_tag, dict_constructor)
+
+class IntField(object):
+    def __init__(self, name, position, length, signed):
+        self.name = name
+        self.position = position
+        self.length = length
+        self.signed = signed
+
+        if not self.length in [1, 2, 4]:
+            raise Exception("bad length " + str(self.length))
+
+        self.user_type = ('u' if not signed else '') + 'int' + str(length * 8) + '_t'
+
+    def getter_sig(self):
+        return "{0}* {1}".format(self.user_type, self.name)
+
+    def unpack(self):
+        if self.length == 1:
+            return "*{0} = data[{1}];".format(self.name, self.position)
+        elif self.length == 2:
+            return "*{0} = SW_TO_SHORT(data + {1});".format(self.name, self.position)
+        elif self.length == 4:
+            return "*{0} = DW_TO_INT(data + {1});".format(self.name, self.position)
+
+    def setter_sig(self):
+        return "{0} {1}".format(self.user_type, self.name)
+
+    def pack(self):
+        if self.length == 1:
+            return "data[{0}] = {1};".format(self.position, self.name)
+        elif self.length == 2:
+            return "SHORT_TO_SW({0}, data + {1});".format(self.name, self.position)
+        elif self.length == 4:
+            return "INT_TO_DW({0}, data + {1});".format(self.name, self.position)
+
+    def spec(self):
+        rep = [('position', self.position), ('length', self.length)]
+        if self.signed:
+            rep.append(('signed', True))
+        return rep
+
+    @staticmethod
+    def load(spec):
+        return IntField(spec['name'], spec['position'], spec['length'], spec['signed'] if signed in spec else False)
+
+def load_field(name, spec):
+    if spec['type'] == 'int':
+        return IntField(name, spec['position'], spec['length'], spec.get('signed', False))
+    else:
+        raise Exception("unknown field type '{0}'".format(spec['type']))
+
+GETTER_TEMPLATE = """/** @ingroup ctrl
+ * {gen_doc}
+ * @param devh UVC device handle
+ * {args_doc}
+ * @param req_code UVC_GET_* request to execute
+ */
+uvc_error_t uvc_get_{control_name}(uvc_device_handle_t *devh, {args_signature}, enum uvc_req_code req_code) {{
+  uint8_t data[{control_length}];
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    {control_code} << 8,
+    {unit_fn} << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data)) {{
+    {unpack}
+    return UVC_SUCCESS;
+  }} else {{
+    return ret;
+  }}
+}}
+"""
+
+SETTER_TEMPLATE = """/** @ingroup ctrl
+ * {gen_doc}
+ * @param devh UVC device handle
+ * {args_doc}
+ */
+uvc_error_t uvc_set_{control_name}(uvc_device_handle_t *devh, {args_signature}) {{
+  uint8_t data[{control_length}];
+  uvc_error_t ret;
+
+  {pack}
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    {control_code} << 8,
+    {unit_fn} << 8 | devh->info->ctrl_if.bInterfaceNumber,
+    data,
+    sizeof(data),
+    0);
+
+  if (ret == sizeof(data))
+    return UVC_SUCCESS;
+  else
+    return ret;
+}}
+"""
+
+def gen_decl(unit_name, unit, control_name, control):
+    fields = [(load_field(field_name, field_details), field_details['doc']) for field_name, field_details in control['fields'].items()] if 'fields' in control else []
+
+    get_args_signature = ', '.join([field.getter_sig() for (field, desc) in fields])
+    set_args_signature = ', '.join([field.setter_sig() for (field, desc) in fields])
+
+    return "uvc_error_t uvc_get_{function_name}(uvc_device_handle_t *devh, {args_signature}, enum uvc_req_code req_code);\n".format(**{
+        "function_name": control_name,
+        "args_signature": get_args_signature
+    }) + "uvc_error_t uvc_set_{function_name}(uvc_device_handle_t *devh, {args_signature});\n".format(**{
+        "function_name": control_name,
+        "args_signature": set_args_signature
+    })
+
+def gen_ctrl(unit_name, unit, control_name, control):
+    fields = [(load_field(field_name, field_details), field_details['doc']) for field_name, field_details in control['fields'].items()] if 'fields' in control else []
+
+    get_args_signature = ', '.join([field.getter_sig() for (field, desc) in fields])
+    set_args_signature = ', '.join([field.setter_sig() for (field, desc) in fields])
+    unpack = "\n    ".join([field.unpack() for (field, desc) in fields])
+    pack = "\n  ".join([field.pack() for (field, desc) in fields])
+
+    get_gen_doc_raw = None
+    set_gen_doc_raw = None
+
+    if 'doc' in control:
+        doc = control['doc']
+
+        if isinstance(doc, str):
+            get_gen_doc_raw = "\n * ".join(doc.splitlines())
+            set_gen_doc_raw = get_gen_doc_raw
+        else:
+            if 'get' in doc:
+                get_gen_doc_raw = "\n * ".join(doc['get'].splitlines())
+            if 'set' in doc:
+                set_gen_doc_raw = "\n * ".join(doc['set'].splitlines())
+
+    if get_gen_doc_raw is not None:
+        get_gen_doc = get_gen_doc_raw.format(gets_sets='Reads')
+    else:
+        get_gen_doc = '@brief Reads the ' + control['control'] + ' control.'
+
+    if set_gen_doc_raw is not None:
+        set_gen_doc = set_gen_doc_raw.format(gets_sets='Sets')
+    else:
+        set_gen_doc = '@brief Sets the ' + control['control'] + ' control.'
+
+    get_args_doc = "\n * ".join(["@param[out] {0} {1}".format(field.name, desc) for (field, desc) in fields])
+    set_args_doc = "\n * ".join(["@param {0} {1}".format(field.name, desc) for (field, desc) in fields])
+
+    control_code = 'UVC_' + unit['control_prefix'] + '_' + control['control'] + '_CONTROL'
+
+    unit_fn = "uvc_get_camera_terminal(devh)->bTerminalID" if (unit_name == "camera_terminal") else ("uvc_get_" + unit_name + "s(devh)->bUnitID")
+
+    return GETTER_TEMPLATE.format(
+        unit=unit,
+        unit_fn=unit_fn,
+        control_name=control_name,
+        control_code=control_code,
+        control_length=control['length'],
+        args_signature=get_args_signature,
+        args_doc=get_args_doc,
+        gen_doc=get_gen_doc,
+        unpack=unpack) + "\n\n" + SETTER_TEMPLATE.format(
+            unit=unit,
+            unit_fn=unit_fn,
+            control_name=control_name,
+            control_code=control_code,
+            control_length=control['length'],
+            args_signature=set_args_signature,
+            args_doc=set_args_doc,
+            gen_doc=set_gen_doc,
+            pack=pack
+        )
+
+def export_unit(unit):
+    def fmt_doc(doc):
+        def wrap_doc_entry(entry):
+            if "\n" in entry:
+                return literal(entry)
+            else:
+                return entry
+
+        if isinstance(doc, str):
+            return wrap_doc_entry(doc)
+        else:
+            return OrderedDict([(mode, wrap_doc_entry(text)) for mode, text in doc.items()])
+
+    def fmt_ctrl(control_name, control_details):
+        contents = OrderedDict()
+        contents['control'] = control_details['control']
+        contents['length'] = control_details['length']
+        contents['fields'] = control_details['fields']
+
+        if 'doc' in control_details:
+            contents['doc'] = fmt_doc(control_details['doc'])
+
+        return (control_name, contents)
+
+    unit_out = OrderedDict()
+    unit_out['type'] = unit['type']
+    if 'guid' in unit:
+        unit_out['guid'] = unit['guid']
+    if 'description' in unit:
+        unit_out['description'] = unit['description']
+    if 'control_prefix' in unit:
+        unit_out['control_prefix'] = unit['control_prefix']
+    unit_out['controls'] = OrderedDict([fmt_ctrl(ctrl_name, ctrl_details) for ctrl_name, ctrl_details in unit['controls'].items()])
+    return unit_out
+
+if __name__ == '__main__':
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], "hi:", ["help", "input="])
+    except getopt.GetoptError as err:
+        print(str(err))
+        usage()
+        sys.exit(-1)
+
+    inputs = []
+
+    for opt, val in opts:
+        if opt in ('-h', '--help'):
+            usage()
+            sys.exit(0)
+        elif opt in ('-i', '--input'):
+            inputs.append(val)
+
+    mode = None
+    for arg in args:
+        if arg in ('def', 'decl', 'yaml'):
+            if mode is None:
+                mode = arg
+            else:
+                print("Can't specify more than one mode")
+                sys.exit(-1)
+        else:
+            print("Invalid mode '{0}'".format(arg))
+            sys.exit(-1)
+
+    def iterunits():
+        for input_file in inputs:
+            with open(input_file, "r") as fp:
+                units = yaml.load(fp)['units']
+                for unit_name, unit_details in units.iteritems():
+                    yield unit_name, unit_details
+
+    if mode == 'def':
+        print("""/* This is an AUTO-GENERATED file! Update it with the output of `ctrl-gen.py def`. */
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+static const int REQ_TYPE_SET = 0x21;
+static const int REQ_TYPE_GET = 0xa1;
+""")
+        fun = gen_ctrl
+    elif mode == 'decl':
+        fun = gen_decl
+    elif mode == 'yaml':
+        exported_units = OrderedDict()
+        for unit_name, unit_details in iterunits():
+            exported_units[unit_name] = export_unit(unit_details)
+
+        yaml.dump({'units': exported_units}, sys.stdout, default_flow_style=False)
+        sys.exit(0)
+
+    for unit_name, unit_details in iterunits():
+        for control_name, control_details in unit_details['controls'].iteritems():
+            code = fun(unit_name, unit_details, control_name, control_details)
+            print(code)

collector/core/gripper/camera_service_src/third_party/libuvc/src/ctrl.c

@@ -0,0 +1,165 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+/**
+ * @defgroup ctrl Video capture and processing controls
+ * @brief Functions for manipulating device settings and stream parameters
+ *
+ * The `uvc_get_*` and `uvc_set_*` functions are used to read and write the settings associated
+ * with the device's input, processing and output units.
+ */
+
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+static const int REQ_TYPE_SET = 0x21;
+static const int REQ_TYPE_GET = 0xa1;
+
+/***** GENERIC CONTROLS *****/
+/**
+ * @brief Get the length of a control on a terminal or unit.
+ * 
+ * @param devh UVC device handle
+ * @param unit Unit or Terminal ID; obtain this from the uvc_extension_unit_t describing the extension unit
+ * @param ctrl Vendor-specific control number to query
+ * @return On success, the length of the control as reported by the device. Otherwise,
+ *   a uvc_error_t error describing the error encountered.
+ * @ingroup ctrl
+ */
+int uvc_get_ctrl_len(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl) {
+  unsigned char buf[2];
+
+  int ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, UVC_GET_LEN,
+    ctrl << 8,
+    unit << 8 | devh->info->ctrl_if.bInterfaceNumber,		// XXX saki
+    buf,
+    2,
+    0 /* timeout */);
+
+  if (ret < 0)
+    return ret;
+  else
+    return (unsigned short)SW_TO_SHORT(buf);
+}
+
+/**
+ * @brief Perform a GET_* request from an extension unit.
+ * 
+ * @param devh UVC device handle
+ * @param unit Unit ID; obtain this from the uvc_extension_unit_t describing the extension unit
+ * @param ctrl Control number to query
+ * @param data Data buffer to be filled by the device
+ * @param len Size of data buffer
+ * @param req_code GET_* request to execute
+ * @return On success, the number of bytes actually transferred. Otherwise,
+ *   a uvc_error_t error describing the error encountered.
+ * @ingroup ctrl
+ */
+int uvc_get_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len, enum uvc_req_code req_code) {
+  return libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    ctrl << 8,
+    unit << 8 | devh->info->ctrl_if.bInterfaceNumber,		// XXX saki
+    data,
+    len,
+    0 /* timeout */);
+}
+
+/**
+ * @brief Perform a SET_CUR request to a terminal or unit.
+ * 
+ * @param devh UVC device handle
+ * @param unit Unit or Terminal ID
+ * @param ctrl Control number to set
+ * @param data Data buffer to be sent to the device
+ * @param len Size of data buffer
+ * @return On success, the number of bytes actually transferred. Otherwise,
+ *   a uvc_error_t error describing the error encountered.
+ * @ingroup ctrl
+ */
+int uvc_set_ctrl(uvc_device_handle_t *devh, uint8_t unit, uint8_t ctrl, void *data, int len) {
+  return libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    ctrl << 8,
+    unit << 8 | devh->info->ctrl_if.bInterfaceNumber,		// XXX saki
+    data,
+    len,
+    0 /* timeout */);
+}
+
+/***** INTERFACE CONTROLS *****/
+uvc_error_t uvc_get_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode *mode, enum uvc_req_code req_code) {
+  uint8_t mode_char;
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_GET, req_code,
+    UVC_VC_VIDEO_POWER_MODE_CONTROL << 8,
+    devh->info->ctrl_if.bInterfaceNumber,	// XXX saki
+    &mode_char,
+    sizeof(mode_char),
+    0);
+
+  if (ret == 1) {
+    *mode = mode_char;
+    return UVC_SUCCESS;
+  } else {
+    return ret;
+  }
+}
+
+uvc_error_t uvc_set_power_mode(uvc_device_handle_t *devh, enum uvc_device_power_mode mode) {
+  uint8_t mode_char = mode;
+  uvc_error_t ret;
+
+  ret = libusb_control_transfer(
+    devh->usb_devh,
+    REQ_TYPE_SET, UVC_SET_CUR,
+    UVC_VC_VIDEO_POWER_MODE_CONTROL << 8,
+    devh->info->ctrl_if.bInterfaceNumber,	// XXX saki
+    &mode_char,
+    sizeof(mode_char),
+    0);
+
+  if (ret == 1)
+    return UVC_SUCCESS;
+  else
+    return ret;
+}
+
+/** @todo Request Error Code Control (UVC 1.5, 4.2.1.2) */

collector/core/gripper/camera_service_src/third_party/libuvc/src/device.c

@@ -0,0 +1,2005 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+/**
+ * @defgroup device Device handling and enumeration
+ * @brief Support for finding, inspecting and opening UVC devices
+ */
+
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+int uvc_already_open(uvc_context_t *ctx, struct libusb_device *usb_dev);
+void uvc_free_devh(uvc_device_handle_t *devh);
+
+uvc_error_t uvc_get_device_info(uvc_device_handle_t *devh, uvc_device_info_t **info);
+void uvc_free_device_info(uvc_device_info_t *info);
+
+uvc_error_t uvc_scan_control(uvc_device_handle_t *devh, uvc_device_info_t *info);
+uvc_error_t uvc_parse_vc(uvc_device_t *dev,
+			 uvc_device_info_t *info,
+			 const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vc_selector_unit(uvc_device_t *dev,
+					uvc_device_info_t *info,
+					const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vc_extension_unit(uvc_device_t *dev,
+					uvc_device_info_t *info,
+					const unsigned char *block,
+					size_t block_size);
+uvc_error_t uvc_parse_vc_header(uvc_device_t *dev,
+				uvc_device_info_t *info,
+				const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vc_input_terminal(uvc_device_t *dev,
+					uvc_device_info_t *info,
+					const unsigned char *block,
+					size_t block_size);
+uvc_error_t uvc_parse_vc_processing_unit(uvc_device_t *dev,
+					 uvc_device_info_t *info,
+					 const unsigned char *block,
+					 size_t block_size);
+
+uvc_error_t uvc_scan_streaming(uvc_device_t *dev,
+			       uvc_device_info_t *info,
+			       int interface_idx);
+uvc_error_t uvc_parse_vs(uvc_device_t *dev,
+			 uvc_device_info_t *info,
+			 uvc_streaming_interface_t *stream_if,
+			 const unsigned char *block, size_t block_size);
+uvc_error_t uvc_parse_vs_format_uncompressed(uvc_streaming_interface_t *stream_if,
+					     const unsigned char *block,
+					     size_t block_size);
+uvc_error_t uvc_parse_vs_format_mjpeg(uvc_streaming_interface_t *stream_if,
+					     const unsigned char *block,
+					     size_t block_size);
+uvc_error_t uvc_parse_vs_frame_uncompressed(uvc_streaming_interface_t *stream_if,
+					    const unsigned char *block,
+					    size_t block_size);
+uvc_error_t uvc_parse_vs_frame_format(uvc_streaming_interface_t *stream_if,
+					    const unsigned char *block,
+					    size_t block_size);
+uvc_error_t uvc_parse_vs_frame_frame(uvc_streaming_interface_t *stream_if,
+					    const unsigned char *block,
+					    size_t block_size);
+uvc_error_t uvc_parse_vs_input_header(uvc_streaming_interface_t *stream_if,
+				      const unsigned char *block,
+				      size_t block_size);
+
+void LIBUSB_CALL _uvc_status_callback(struct libusb_transfer *transfer);
+
+/** @internal
+ * @brief Test whether the specified USB device has been opened as a UVC device
+ * @ingroup device
+ *
+ * @param ctx Context in which to search for the UVC device
+ * @param usb_dev USB device to find
+ * @return true if the device is open in this context
+ */
+int uvc_already_open(uvc_context_t *ctx, struct libusb_device *usb_dev) {
+  uvc_device_handle_t *devh;
+
+  DL_FOREACH(ctx->open_devices, devh) {
+    if (usb_dev == devh->dev->usb_dev)
+      return 1;
+  }
+
+  return 0;
+}
+
+/** @brief Finds a camera identified by vendor, product and/or serial number
+ * @ingroup device
+ *
+ * @param[in] ctx UVC context in which to search for the camera
+ * @param[out] dev Reference to the camera, or NULL if not found
+ * @param[in] vid Vendor ID number, optional
+ * @param[in] pid Product ID number, optional
+ * @param[in] sn Serial number or NULL
+ * @return Error finding device or UVC_SUCCESS
+ */
+uvc_error_t uvc_find_device(
+    uvc_context_t *ctx, uvc_device_t **dev,
+    int vid, int pid, const char *sn) {
+  uvc_error_t ret = UVC_SUCCESS;
+
+  uvc_device_t **list;
+  uvc_device_t *test_dev;
+  int dev_idx;
+  int found_dev;
+
+  UVC_ENTER();
+
+  ret = uvc_get_device_list(ctx, &list);
+
+  if (ret != UVC_SUCCESS) {
+    UVC_EXIT(ret);
+    return ret;
+  }
+
+  dev_idx = 0;
+  found_dev = 0;
+
+  while (!found_dev && (test_dev = list[dev_idx++]) != NULL) {
+    uvc_device_descriptor_t *desc;
+
+    if (uvc_get_device_descriptor(test_dev, &desc) != UVC_SUCCESS)
+      continue;
+
+    if ((!vid || desc->idVendor == vid)
+        && (!pid || desc->idProduct == pid)
+        && (!sn || (desc->serialNumber && !strcmp(desc->serialNumber, sn))))
+      found_dev = 1;
+
+    uvc_free_device_descriptor(desc);
+  }
+
+  if (found_dev)
+    uvc_ref_device(test_dev);
+
+  uvc_free_device_list(list, 1);
+
+  if (found_dev) {
+    *dev = test_dev;
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+  } else {
+    UVC_EXIT(UVC_ERROR_NO_DEVICE);
+    return UVC_ERROR_NO_DEVICE;
+  }
+}
+
+/** @brief Finds all cameras identified by vendor, product and/or serial number
+ * @ingroup device
+ *
+ * @param[in] ctx UVC context in which to search for the camera
+ * @param[out] devs List of matching cameras
+ * @param[in] vid Vendor ID number, optional
+ * @param[in] pid Product ID number, optional
+ * @param[in] sn Serial number or NULL
+ * @return Error finding device or UVC_SUCCESS
+ */
+uvc_error_t uvc_find_devices(
+    uvc_context_t *ctx, uvc_device_t ***devs,
+    int vid, int pid, const char *sn) {
+  uvc_error_t ret = UVC_SUCCESS;
+
+  uvc_device_t **list;
+  uvc_device_t *test_dev;
+  int dev_idx;
+  int found_dev;
+
+  uvc_device_t **list_internal;
+  int num_uvc_devices;
+
+  UVC_ENTER();
+
+  ret = uvc_get_device_list(ctx, &list);
+
+  if (ret != UVC_SUCCESS) {
+    UVC_EXIT(ret);
+    return ret;
+  }
+
+  num_uvc_devices = 0;
+  dev_idx = 0;
+  found_dev = 0;
+
+  list_internal = malloc(sizeof(*list_internal));
+  *list_internal = NULL;
+
+  while ((test_dev = list[dev_idx++]) != NULL) {
+    uvc_device_descriptor_t *desc;
+
+    if (uvc_get_device_descriptor(test_dev, &desc) != UVC_SUCCESS)
+      continue;
+
+    if ((!vid || desc->idVendor == vid)
+        && (!pid || desc->idProduct == pid)
+        && (!sn || (desc->serialNumber && !strcmp(desc->serialNumber, sn)))) {
+      found_dev = 1;
+      uvc_ref_device(test_dev);
+
+      num_uvc_devices++;
+      list_internal = realloc(list_internal, (num_uvc_devices + 1) * sizeof(*list_internal));
+
+      list_internal[num_uvc_devices - 1] = test_dev;
+      list_internal[num_uvc_devices] = NULL;
+    }
+
+    uvc_free_device_descriptor(desc);
+  }
+
+  uvc_free_device_list(list, 1);
+
+  if (found_dev) {
+    *devs = list_internal;
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+  } else {
+    UVC_EXIT(UVC_ERROR_NO_DEVICE);
+    return UVC_ERROR_NO_DEVICE;
+  }
+}
+
+/** @brief Get the number of the bus to which the device is attached
+ * @ingroup device
+ */
+uint8_t uvc_get_bus_number(uvc_device_t *dev) {
+  return libusb_get_bus_number(dev->usb_dev);
+}
+
+/** @brief Get the number assigned to the device within its bus
+ * @ingroup device
+ */
+uint8_t uvc_get_device_address(uvc_device_t *dev) {
+  return libusb_get_device_address(dev->usb_dev);
+}
+
+int uvc_get_port_numbers(uvc_device_t *dev, uint8_t *ports,
+                         uint8_t port_count) {
+  if (dev == NULL || ports == NULL || port_count == 0)
+    return LIBUSB_ERROR_INVALID_PARAM;
+  return libusb_get_port_numbers(dev->usb_dev, ports, port_count);
+}
+
+static uvc_error_t uvc_open_internal(uvc_device_t *dev, struct libusb_device_handle *usb_devh, uvc_device_handle_t **devh);
+
+#if LIBUSB_API_VERSION >= 0x01000107
+/** @brief Wrap a platform-specific system device handle and obtain a UVC device handle.
+ * The handle allows you to use libusb to perform I/O on the device in question.
+ *
+ * On Linux, the system device handle must be a valid file descriptor opened on the device node.
+ *
+ * The system device handle must remain open until uvc_close() is called. The system device handle will not be closed by uvc_close().
+ * @ingroup device
+ *
+ * @param sys_dev the platform-specific system device handle
+ * @param context UVC context to prepare the device
+ * @param[out] devh Handle on opened device
+ * @return Error opening device or SUCCESS
+ */
+uvc_error_t uvc_wrap(
+    int sys_dev,
+    uvc_context_t *context,
+    uvc_device_handle_t **devh) {
+  uvc_error_t ret;
+  struct libusb_device_handle *usb_devh;
+
+  UVC_ENTER();
+
+  uvc_device_t *dev = NULL;
+  int err = libusb_wrap_sys_device(context->usb_ctx, sys_dev, &usb_devh);
+  UVC_DEBUG("libusb_wrap_sys_device() = %d", err);
+  if (err != LIBUSB_SUCCESS) {
+    UVC_EXIT(err);
+    return err;
+  }
+
+  dev = calloc(1, sizeof(uvc_device_t));
+  dev->ctx = context;
+  dev->usb_dev = libusb_get_device(usb_devh);
+
+  ret = uvc_open_internal(dev, usb_devh, devh);
+  UVC_EXIT(ret);
+  return ret;
+}
+#endif
+
+/** @brief Open a UVC device
+ * @ingroup device
+ *
+ * @param dev Device to open
+ * @param[out] devh Handle on opened device
+ * @return Error opening device or SUCCESS
+ */
+uvc_error_t uvc_open(
+    uvc_device_t *dev,
+    uvc_device_handle_t **devh) {
+  uvc_error_t ret;
+  struct libusb_device_handle *usb_devh;
+
+  UVC_ENTER();
+
+  ret = libusb_open(dev->usb_dev, &usb_devh);
+  UVC_DEBUG("libusb_open() = %d", ret);
+
+  if (ret != UVC_SUCCESS) {
+    UVC_EXIT(ret);
+    return ret;
+  }
+
+  ret = uvc_open_internal(dev, usb_devh, devh);
+  UVC_EXIT(ret);
+  return ret;
+}
+
+static uvc_error_t uvc_open_internal(
+    uvc_device_t *dev,
+    struct libusb_device_handle *usb_devh,
+    uvc_device_handle_t **devh) {
+  uvc_error_t ret;
+  uvc_device_handle_t *internal_devh;
+  struct libusb_device_descriptor desc;
+
+  UVC_ENTER();
+
+  uvc_ref_device(dev);
+
+  internal_devh = calloc(1, sizeof(*internal_devh));
+  internal_devh->dev = dev;
+  internal_devh->usb_devh = usb_devh;
+
+  ret = uvc_get_device_info(internal_devh, &(internal_devh->info));
+
+  if (ret != UVC_SUCCESS)
+    goto fail;
+
+  UVC_DEBUG("claiming control interface %d", internal_devh->info->ctrl_if.bInterfaceNumber);
+  ret = uvc_claim_if(internal_devh, internal_devh->info->ctrl_if.bInterfaceNumber);
+  if (ret != UVC_SUCCESS)
+    goto fail;
+
+  libusb_get_device_descriptor(dev->usb_dev, &desc);
+  internal_devh->is_isight = (desc.idVendor == 0x05ac && desc.idProduct == 0x8501);
+
+  if (internal_devh->info->ctrl_if.bEndpointAddress) {
+    internal_devh->status_xfer = libusb_alloc_transfer(0);
+    if (!internal_devh->status_xfer) {
+      ret = UVC_ERROR_NO_MEM;
+      goto fail;
+    }
+
+    libusb_fill_interrupt_transfer(internal_devh->status_xfer,
+                                   usb_devh,
+                                   internal_devh->info->ctrl_if.bEndpointAddress,
+                                   internal_devh->status_buf,
+                                   sizeof(internal_devh->status_buf),
+                                   _uvc_status_callback,
+                                   internal_devh,
+                                   0);
+    ret = libusb_submit_transfer(internal_devh->status_xfer);
+    UVC_DEBUG("libusb_submit_transfer() = %d", ret);
+
+    if (ret) {
+      fprintf(stderr,
+              "uvc: device has a status interrupt endpoint, but unable to read from it\n");
+      goto fail;
+    }
+  }
+
+  if (dev->ctx->own_usb_ctx && dev->ctx->open_devices == NULL) {
+    /* Since this is our first device, we need to spawn the event handler thread */
+    uvc_start_handler_thread(dev->ctx);
+  }
+
+  DL_APPEND(dev->ctx->open_devices, internal_devh);
+  *devh = internal_devh;
+
+  UVC_EXIT(ret);
+
+  return ret;
+
+ fail:
+  if ( internal_devh->info ) {
+    uvc_release_if(internal_devh, internal_devh->info->ctrl_if.bInterfaceNumber);
+  }
+  libusb_close(usb_devh);
+  uvc_unref_device(dev);
+  uvc_free_devh(internal_devh);
+
+  UVC_EXIT(ret);
+
+  return ret;
+}
+
+/**
+ * @internal
+ * @brief Parses the complete device descriptor for a device
+ * @ingroup device
+ * @note Free *info with uvc_free_device_info when you're done
+ *
+ * @param dev Device to parse descriptor for
+ * @param info Where to store a pointer to the new info struct
+ */
+uvc_error_t uvc_get_device_info(uvc_device_handle_t *devh,
+				uvc_device_info_t **info) {
+  uvc_error_t ret;
+  uvc_device_info_t *internal_info;
+
+  UVC_ENTER();
+
+  internal_info = calloc(1, sizeof(*internal_info));
+  if (!internal_info) {
+    UVC_EXIT(UVC_ERROR_NO_MEM);
+    return UVC_ERROR_NO_MEM;
+  }
+
+  if (libusb_get_config_descriptor(devh->dev->usb_dev,
+				   0,
+				   &(internal_info->config)) != 0) {
+    free(internal_info);
+    UVC_EXIT(UVC_ERROR_IO);
+    return UVC_ERROR_IO;
+  }
+
+  ret = uvc_scan_control(devh, internal_info);
+  if (ret != UVC_SUCCESS) {
+    uvc_free_device_info(internal_info);
+    UVC_EXIT(ret);
+    return ret;
+  }
+
+  *info = internal_info;
+
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/**
+ * @internal
+ * @brief Frees the device descriptor for a device
+ * @ingroup device
+ *
+ * @param info Which device info block to free
+ */
+void uvc_free_device_info(uvc_device_info_t *info) {
+  uvc_input_terminal_t *input_term, *input_term_tmp;
+  uvc_processing_unit_t *proc_unit, *proc_unit_tmp;
+  uvc_extension_unit_t *ext_unit, *ext_unit_tmp;
+
+  uvc_streaming_interface_t *stream_if, *stream_if_tmp;
+  uvc_format_desc_t *format, *format_tmp;
+  uvc_frame_desc_t *frame, *frame_tmp;
+  uvc_still_frame_desc_t *still_frame, *still_frame_tmp;
+  uvc_still_frame_res_t *still_res, *still_res_tmp;
+
+  UVC_ENTER();
+
+  DL_FOREACH_SAFE(info->ctrl_if.input_term_descs, input_term, input_term_tmp) {
+    DL_DELETE(info->ctrl_if.input_term_descs, input_term);
+    free(input_term);
+  }
+
+  DL_FOREACH_SAFE(info->ctrl_if.processing_unit_descs, proc_unit, proc_unit_tmp) {
+    DL_DELETE(info->ctrl_if.processing_unit_descs, proc_unit);
+    free(proc_unit);
+  }
+
+  DL_FOREACH_SAFE(info->ctrl_if.extension_unit_descs, ext_unit, ext_unit_tmp) {
+    DL_DELETE(info->ctrl_if.extension_unit_descs, ext_unit);
+    free(ext_unit);
+  }
+
+  DL_FOREACH_SAFE(info->stream_ifs, stream_if, stream_if_tmp) {
+    DL_FOREACH_SAFE(stream_if->format_descs, format, format_tmp) {
+      DL_FOREACH_SAFE(format->frame_descs, frame, frame_tmp) {
+        if (frame->intervals)
+          free(frame->intervals);
+
+        DL_DELETE(format->frame_descs, frame);
+        free(frame);
+      }
+
+      if(format->still_frame_desc) {
+        DL_FOREACH_SAFE(format->still_frame_desc, still_frame, still_frame_tmp) {
+          DL_FOREACH_SAFE(still_frame->imageSizePatterns, still_res, still_res_tmp) {
+            free(still_res);
+          }
+
+          if(still_frame->bCompression) {
+              free(still_frame->bCompression);
+          }
+          free(still_frame);
+        }
+      }
+
+      DL_DELETE(stream_if->format_descs, format);
+      free(format);
+    }
+
+    DL_DELETE(info->stream_ifs, stream_if);
+    free(stream_if);
+  }
+
+  if (info->config)
+    libusb_free_config_descriptor(info->config);
+
+  free(info);
+
+  UVC_EXIT_VOID();
+}
+
+static uvc_error_t get_device_descriptor(
+        uvc_device_handle_t *devh,
+        uvc_device_descriptor_t **desc) {
+  uvc_device_descriptor_t *desc_internal;
+  struct libusb_device_descriptor usb_desc;
+  struct libusb_device_handle *usb_devh = devh->usb_devh;
+  uvc_error_t ret;
+
+  UVC_ENTER();
+
+  ret = libusb_get_device_descriptor(devh->dev->usb_dev, &usb_desc);
+
+  if (ret != UVC_SUCCESS) {
+    UVC_EXIT(ret);
+    return ret;
+  }
+
+  desc_internal = calloc(1, sizeof(*desc_internal));
+  desc_internal->idVendor = usb_desc.idVendor;
+  desc_internal->idProduct = usb_desc.idProduct;
+
+  unsigned char buf[64];
+
+  int bytes = libusb_get_string_descriptor_ascii(
+          usb_devh, usb_desc.iSerialNumber, buf, sizeof(buf));
+
+  if (bytes > 0)
+    desc_internal->serialNumber = strdup((const char*) buf);
+
+  bytes = libusb_get_string_descriptor_ascii(
+          usb_devh, usb_desc.iManufacturer, buf, sizeof(buf));
+
+  if (bytes > 0)
+    desc_internal->manufacturer = strdup((const char*) buf);
+
+  bytes = libusb_get_string_descriptor_ascii(
+          usb_devh, usb_desc.iProduct, buf, sizeof(buf));
+
+  if (bytes > 0)
+    desc_internal->product = strdup((const char*) buf);
+
+  *desc = desc_internal;
+
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/**
+ * @brief Get a descriptor that contains the general information about
+ * a device
+ * @ingroup device
+ *
+ * Free *desc with uvc_free_device_descriptor when you're done.
+ *
+ * @param dev Device to fetch information about
+ * @param[out] desc Descriptor structure
+ * @return Error if unable to fetch information, else SUCCESS
+ */
+uvc_error_t uvc_get_device_descriptor(
+    uvc_device_t *dev,
+    uvc_device_descriptor_t **desc) {
+  uvc_device_descriptor_t *desc_internal;
+  struct libusb_device_descriptor usb_desc;
+  struct libusb_device_handle *usb_devh;
+  uvc_error_t ret;
+
+  UVC_ENTER();
+
+  ret = libusb_get_device_descriptor(dev->usb_dev, &usb_desc);
+
+  if (ret != UVC_SUCCESS) {
+    UVC_EXIT(ret);
+    return ret;
+  }
+
+  desc_internal = calloc(1, sizeof(*desc_internal));
+  desc_internal->idVendor = usb_desc.idVendor;
+  desc_internal->idProduct = usb_desc.idProduct;
+
+  if (libusb_open(dev->usb_dev, &usb_devh) == 0) {
+    unsigned char buf[64];
+
+    int bytes = libusb_get_string_descriptor_ascii(
+        usb_devh, usb_desc.iSerialNumber, buf, sizeof(buf));
+
+    if (bytes > 0)
+      desc_internal->serialNumber = strdup((const char*) buf);
+
+    bytes = libusb_get_string_descriptor_ascii(
+        usb_devh, usb_desc.iManufacturer, buf, sizeof(buf));
+
+    if (bytes > 0)
+      desc_internal->manufacturer = strdup((const char*) buf);
+
+    bytes = libusb_get_string_descriptor_ascii(
+        usb_devh, usb_desc.iProduct, buf, sizeof(buf));
+
+    if (bytes > 0)
+      desc_internal->product = strdup((const char*) buf);
+
+    libusb_close(usb_devh);
+  } else {
+    UVC_DEBUG("can't open device %04x:%04x, not fetching serial etc.",
+	      usb_desc.idVendor, usb_desc.idProduct);
+  }
+
+  *desc = desc_internal;
+
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/**
+ * @brief Frees a device descriptor created with uvc_get_device_descriptor
+ * @ingroup device
+ *
+ * @param desc Descriptor to free
+ */
+void uvc_free_device_descriptor(
+    uvc_device_descriptor_t *desc) {
+  UVC_ENTER();
+
+  if (desc->serialNumber)
+    free((void*) desc->serialNumber);
+
+  if (desc->manufacturer)
+    free((void*) desc->manufacturer);
+
+  if (desc->product)
+    free((void*) desc->product);
+
+  free(desc);
+
+  UVC_EXIT_VOID();
+}
+
+/**
+ * @brief Get a list of the UVC devices attached to the system
+ * @ingroup device
+ *
+ * @note Free the list with uvc_free_device_list when you're done.
+ *
+ * @param ctx UVC context in which to list devices
+ * @param list List of uvc_device structures
+ * @return Error if unable to list devices, else SUCCESS
+ */
+uvc_error_t uvc_get_device_list(
+    uvc_context_t *ctx,
+    uvc_device_t ***list) {
+  struct libusb_device **usb_dev_list;
+  struct libusb_device *usb_dev;
+  int num_usb_devices;
+
+  uvc_device_t **list_internal;
+  int num_uvc_devices;
+
+  /* per device */
+  int dev_idx;
+  struct libusb_config_descriptor *config;
+  struct libusb_device_descriptor desc;
+  uint8_t got_interface;
+
+  /* per interface */
+  int interface_idx;
+  const struct libusb_interface *interface;
+
+  /* per altsetting */
+  int altsetting_idx;
+  const struct libusb_interface_descriptor *if_desc;
+
+  UVC_ENTER();
+
+  num_usb_devices = libusb_get_device_list(ctx->usb_ctx, &usb_dev_list);
+
+  if (num_usb_devices < 0) {
+    UVC_EXIT(UVC_ERROR_IO);
+    return UVC_ERROR_IO;
+  }
+
+  list_internal = malloc(sizeof(*list_internal));
+  *list_internal = NULL;
+
+  num_uvc_devices = 0;
+  dev_idx = -1;
+
+  while ((usb_dev = usb_dev_list[++dev_idx]) != NULL) {
+    got_interface = 0;
+
+    if (libusb_get_config_descriptor(usb_dev, 0, &config) != 0)
+      continue;
+
+    if ( libusb_get_device_descriptor ( usb_dev, &desc ) != LIBUSB_SUCCESS )
+      continue;
+
+    for (interface_idx = 0;
+	 !got_interface && interface_idx < config->bNumInterfaces;
+	 ++interface_idx) {
+      interface = &config->interface[interface_idx];
+
+      for (altsetting_idx = 0;
+	   !got_interface && altsetting_idx < interface->num_altsetting;
+	   ++altsetting_idx) {
+	if_desc = &interface->altsetting[altsetting_idx];
+
+        // Skip TIS cameras that definitely aren't UVC even though they might
+        // look that way
+
+        if ( 0x199e == desc.idVendor && desc.idProduct  >= 0x8201 &&
+            desc.idProduct <= 0x8208 ) {
+          continue;
+        }
+
+        // Special case for Imaging Source cameras
+	/* Video, Streaming */
+        if ( 0x199e == desc.idVendor && ( 0x8101 == desc.idProduct ||
+            0x8102 == desc.idProduct ) &&
+            if_desc->bInterfaceClass == 255 &&
+            if_desc->bInterfaceSubClass == 2 ) {
+	  got_interface = 1;
+	}
+
+	/* Video, Streaming */
+	if (if_desc->bInterfaceClass == 14 && if_desc->bInterfaceSubClass == 2) {
+	  got_interface = 1;
+	}
+      }
+    }
+
+    libusb_free_config_descriptor(config);
+
+    if (got_interface) {
+      uvc_device_t *uvc_dev = malloc(sizeof(*uvc_dev));
+      uvc_dev->ctx = ctx;
+      uvc_dev->ref = 0;
+      uvc_dev->usb_dev = usb_dev;
+      uvc_ref_device(uvc_dev);
+
+      num_uvc_devices++;
+      list_internal = realloc(list_internal, (num_uvc_devices + 1) * sizeof(*list_internal));
+
+      list_internal[num_uvc_devices - 1] = uvc_dev;
+      list_internal[num_uvc_devices] = NULL;
+
+      UVC_DEBUG("    UVC: %d", dev_idx);
+    } else {
+      UVC_DEBUG("non-UVC: %d", dev_idx);
+    }
+  }
+
+  libusb_free_device_list(usb_dev_list, 1);
+
+  *list = list_internal;
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/**
+ * @brief Frees a list of device structures created with uvc_get_device_list.
+ * @ingroup device
+ *
+ * @param list Device list to free
+ * @param unref_devices Decrement the reference counter for each device
+ * in the list, and destroy any entries that end up with zero references
+ */
+void uvc_free_device_list(uvc_device_t **list, uint8_t unref_devices) {
+  uvc_device_t *dev;
+  int dev_idx = 0;
+
+  UVC_ENTER();
+
+  if (unref_devices) {
+    while ((dev = list[dev_idx++]) != NULL) {
+      uvc_unref_device(dev);
+    }
+  }
+
+  free(list);
+
+  UVC_EXIT_VOID();
+}
+
+/**
+ * @brief Get the uvc_device_t corresponding to an open device
+ * @ingroup device
+ *
+ * @note Unref the uvc_device_t when you're done with it
+ *
+ * @param devh Device handle to an open UVC device
+ */
+uvc_device_t *uvc_get_device(uvc_device_handle_t *devh) {
+  uvc_ref_device(devh->dev);
+  return devh->dev;
+}
+
+uvc_error_t uvc_set_altsetting_override(
+    uvc_device_handle_t *devh,
+    int altsetting,
+    unsigned int payload) {
+  if (devh == NULL) {
+    return UVC_ERROR_INVALID_PARAM;
+  }
+  if (altsetting <= 0) {
+    devh->altsetting_override_valid = 0;
+    devh->altsetting_override_altsetting = 0;
+    devh->altsetting_override_payload = 0;
+    return UVC_SUCCESS;
+  }
+  if (altsetting > 0xff || payload == 0 || payload > 0xffff) {
+    return UVC_ERROR_INVALID_PARAM;
+  }
+  devh->altsetting_override_altsetting = (uint8_t)altsetting;
+  devh->altsetting_override_payload = (uint16_t)payload;
+  devh->altsetting_override_valid = 1;
+  UVC_DEBUG("altsetting override: alt=%d payload=%u", altsetting, payload);
+  return UVC_SUCCESS;
+}
+
+/**
+ * @brief Get the underlying libusb device handle for an open device
+ * @ingroup device
+ *
+ * This can be used to access other interfaces on the same device, e.g.
+ * a webcam microphone.
+ *
+ * @note The libusb device handle is only valid while the UVC device is open;
+ * it will be invalidated upon calling uvc_close.
+ *
+ * @param devh UVC device handle to an open device
+ */
+libusb_device_handle *uvc_get_libusb_handle(uvc_device_handle_t *devh) {
+  return devh->usb_devh;
+}
+
+/**
+ * @brief Get camera terminal descriptor for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list, but iterating through
+ * it will make it no longer the camera terminal
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_input_terminal_t *uvc_get_camera_terminal(uvc_device_handle_t *devh) {
+  const uvc_input_terminal_t *term = uvc_get_input_terminals(devh);
+  while(term != NULL) {
+    if (term->wTerminalType == UVC_ITT_CAMERA) {
+      break;
+    }
+    else {
+      term = term->next;
+    }
+  }
+  return term;
+}
+
+
+/**
+ * @brief Get input terminal descriptors for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list. Iterate through
+ *       it by using the 'next' pointers.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_input_terminal_t *uvc_get_input_terminals(uvc_device_handle_t *devh) {
+  return devh->info->ctrl_if.input_term_descs;
+}
+
+/**
+ * @brief Get output terminal descriptors for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list. Iterate through
+ *       it by using the 'next' pointers.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_output_terminal_t *uvc_get_output_terminals(uvc_device_handle_t *devh) {
+  return NULL; /* @todo */
+}
+
+/**
+ * @brief Get selector unit descriptors for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list. Iterate through
+ *       it by using the 'next' pointers.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_selector_unit_t *uvc_get_selector_units(uvc_device_handle_t *devh) {
+  return devh->info->ctrl_if.selector_unit_descs;
+}
+
+/**
+ * @brief Get processing unit descriptors for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list. Iterate through
+ *       it by using the 'next' pointers.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_processing_unit_t *uvc_get_processing_units(uvc_device_handle_t *devh) {
+  return devh->info->ctrl_if.processing_unit_descs;
+}
+
+/**
+ * @brief Get extension unit descriptors for the open device.
+ *
+ * @note Do not modify the returned structure.
+ * @note The returned structure is part of a linked list. Iterate through
+ *       it by using the 'next' pointers.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_extension_unit_t *uvc_get_extension_units(uvc_device_handle_t *devh) {
+  return devh->info->ctrl_if.extension_unit_descs;
+}
+
+/**
+ * @brief Increment the reference count for a device
+ * @ingroup device
+ *
+ * @param dev Device to reference
+ */
+void uvc_ref_device(uvc_device_t *dev) {
+  UVC_ENTER();
+
+  dev->ref++;
+  libusb_ref_device(dev->usb_dev);
+
+  UVC_EXIT_VOID();
+}
+
+/**
+ * @brief Decrement the reference count for a device
+ * @ingropu device
+ * @note If the count reaches zero, the device will be discarded
+ *
+ * @param dev Device to unreference
+ */
+void uvc_unref_device(uvc_device_t *dev) {
+  UVC_ENTER();
+
+  libusb_unref_device(dev->usb_dev);
+  dev->ref--;
+
+  if (dev->ref == 0)
+    free(dev);
+
+  UVC_EXIT_VOID();
+}
+
+/** @internal
+ * Claim a UVC interface, detaching the kernel driver if necessary.
+ * @ingroup device
+ *
+ * @param devh UVC device handle
+ * @param idx UVC interface index
+ */
+uvc_error_t uvc_claim_if(uvc_device_handle_t *devh, int idx) {
+  int ret = UVC_SUCCESS;
+
+  UVC_ENTER();
+
+  if ( devh->claimed & ( 1 << idx )) {
+    UVC_DEBUG("attempt to claim already-claimed interface %d\n", idx );
+    UVC_EXIT(ret);
+    return ret;
+  }
+
+  /* Tell libusb to detach any active kernel drivers. libusb will keep track of whether
+   * it found a kernel driver for this interface. */
+  ret = libusb_detach_kernel_driver(devh->usb_devh, idx);
+
+  if (ret == UVC_SUCCESS || ret == LIBUSB_ERROR_NOT_FOUND || ret == LIBUSB_ERROR_NOT_SUPPORTED) {
+    UVC_DEBUG("claiming interface %d", idx);
+    if (!( ret = libusb_claim_interface(devh->usb_devh, idx))) {
+      devh->claimed |= ( 1 << idx );
+    }
+  } else {
+    UVC_DEBUG("not claiming interface %d: unable to detach kernel driver (%s)",
+              idx, uvc_strerror(ret));
+  }
+
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/** @internal
+ * Release a UVC interface.
+ * @ingroup device
+ *
+ * @param devh UVC device handle
+ * @param idx UVC interface index
+ */
+uvc_error_t uvc_release_if(uvc_device_handle_t *devh, int idx) {
+  int ret = UVC_SUCCESS;
+
+  UVC_ENTER();
+  UVC_DEBUG("releasing interface %d", idx);
+  if (!( devh->claimed & ( 1 << idx ))) {
+    UVC_DEBUG("attempt to release unclaimed interface %d\n", idx );
+    UVC_EXIT(ret);
+    return ret;
+  }
+
+  /* libusb_release_interface *should* reset the alternate setting to the first available,
+     but sometimes (e.g. on Darwin) it doesn't. Thus, we do it explicitly here.
+     This is needed to de-initialize certain cameras. */
+  libusb_set_interface_alt_setting(devh->usb_devh, idx, 0);
+  ret = libusb_release_interface(devh->usb_devh, idx);
+
+  if (UVC_SUCCESS == ret) {
+    devh->claimed &= ~( 1 << idx );
+    /* Reattach any kernel drivers that were disabled when we claimed this interface */
+    ret = libusb_attach_kernel_driver(devh->usb_devh, idx);
+
+    if (ret == UVC_SUCCESS) {
+      UVC_DEBUG("reattached kernel driver to interface %d", idx);
+    } else if (ret == LIBUSB_ERROR_NOT_FOUND || ret == LIBUSB_ERROR_NOT_SUPPORTED) {
+      ret = UVC_SUCCESS;  /* NOT_FOUND and NOT_SUPPORTED are OK: nothing to do */
+    } else {
+      UVC_DEBUG("error reattaching kernel driver to interface %d: %s",
+                idx, uvc_strerror(ret));
+    }
+  }
+
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/** @internal
+ * Find a device's VideoControl interface and process its descriptor
+ * @ingroup device
+ */
+uvc_error_t uvc_scan_control(uvc_device_handle_t *devh, uvc_device_info_t *info) {
+  const struct libusb_interface_descriptor *if_desc;
+  uvc_error_t parse_ret, ret;
+  int interface_idx;
+  const unsigned char *buffer;
+  size_t buffer_left, block_size;
+
+  UVC_ENTER();
+
+  ret = UVC_SUCCESS;
+  if_desc = NULL;
+
+  uvc_device_descriptor_t* dev_desc;
+  int haveTISCamera = 0;
+  if ( get_device_descriptor ( devh, &dev_desc ) == UVC_SUCCESS ) {
+    if ( 0x199e == dev_desc->idVendor && ( 0x8101 == dev_desc->idProduct ||
+        0x8102 == dev_desc->idProduct )) {
+      haveTISCamera = 1;
+    }
+    uvc_free_device_descriptor ( dev_desc );
+  }
+
+  for (interface_idx = 0; interface_idx < info->config->bNumInterfaces; ++interface_idx) {
+    if_desc = &info->config->interface[interface_idx].altsetting[0];
+
+    if ( haveTISCamera && if_desc->bInterfaceClass == 255 && if_desc->bInterfaceSubClass == 1) // Video, Control
+      break;
+
+    if (if_desc->bInterfaceClass == 14 && if_desc->bInterfaceSubClass == 1) // Video, Control
+      break;
+
+    if_desc = NULL;
+  }
+
+  if (if_desc == NULL) {
+    UVC_EXIT(UVC_ERROR_INVALID_DEVICE);
+    return UVC_ERROR_INVALID_DEVICE;
+  }
+
+  info->ctrl_if.bInterfaceNumber = interface_idx;
+  if (if_desc->bNumEndpoints != 0) {
+    info->ctrl_if.bEndpointAddress = if_desc->endpoint[0].bEndpointAddress;
+  }
+
+  buffer = if_desc->extra;
+  buffer_left = if_desc->extra_length;
+
+  while (buffer_left >= 3) { // parseX needs to see buf[0,2] = length,type
+    block_size = buffer[0];
+    parse_ret = uvc_parse_vc(devh->dev, info, buffer, block_size);
+
+    if (parse_ret != UVC_SUCCESS) {
+      ret = parse_ret;
+      break;
+    }
+
+    buffer_left -= block_size;
+    buffer += block_size;
+  }
+
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/** @internal
+ * @brief Parse a VideoControl header.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc_header(uvc_device_t *dev,
+				uvc_device_info_t *info,
+				const unsigned char *block, size_t block_size) {
+  size_t i;
+  uvc_error_t scan_ret, ret = UVC_SUCCESS;
+
+  UVC_ENTER();
+
+  /*
+  int uvc_version;
+  uvc_version = (block[4] >> 4) * 1000 + (block[4] & 0x0f) * 100
+    + (block[3] >> 4) * 10 + (block[3] & 0x0f);
+  */
+
+  info->ctrl_if.bcdUVC = SW_TO_SHORT(&block[3]);
+
+  switch (info->ctrl_if.bcdUVC) {
+  case 0x0100:
+    info->ctrl_if.dwClockFrequency = DW_TO_INT(block + 7);
+    break;
+  case 0x010a:
+    info->ctrl_if.dwClockFrequency = DW_TO_INT(block + 7);
+    break;
+  case 0x0110:
+    break;
+  default:
+    UVC_EXIT(UVC_ERROR_NOT_SUPPORTED);
+    return UVC_ERROR_NOT_SUPPORTED;
+  }
+
+  for (i = 12; i < block_size; ++i) {
+    scan_ret = uvc_scan_streaming(dev, info, block[i]);
+    if (scan_ret != UVC_SUCCESS) {
+      ret = scan_ret;
+      break;
+    }
+  }
+
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/** @internal
+ * @brief Parse a VideoControl input terminal.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc_input_terminal(uvc_device_t *dev,
+					uvc_device_info_t *info,
+					const unsigned char *block, size_t block_size) {
+  uvc_input_terminal_t *term;
+  size_t i;
+
+  UVC_ENTER();
+
+  /* only supporting camera-type input terminals */
+  if (SW_TO_SHORT(&block[4]) != UVC_ITT_CAMERA) {
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS;
+  }
+
+  term = calloc(1, sizeof(*term));
+
+  term->bTerminalID = block[3];
+  term->wTerminalType = SW_TO_SHORT(&block[4]);
+  term->wObjectiveFocalLengthMin = SW_TO_SHORT(&block[8]);
+  term->wObjectiveFocalLengthMax = SW_TO_SHORT(&block[10]);
+  term->wOcularFocalLength = SW_TO_SHORT(&block[12]);
+
+  for (i = 14 + block[14]; i >= 15; --i)
+    term->bmControls = block[i] + (term->bmControls << 8);
+
+  DL_APPEND(info->ctrl_if.input_term_descs, term);
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoControl processing unit.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc_processing_unit(uvc_device_t *dev,
+					 uvc_device_info_t *info,
+					 const unsigned char *block, size_t block_size) {
+  uvc_processing_unit_t *unit;
+  size_t i;
+
+  UVC_ENTER();
+
+  unit = calloc(1, sizeof(*unit));
+  unit->bUnitID = block[3];
+  unit->bSourceID = block[4];
+
+  for (i = 7 + block[7]; i >= 8; --i)
+    unit->bmControls = block[i] + (unit->bmControls << 8);
+
+  DL_APPEND(info->ctrl_if.processing_unit_descs, unit);
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoControl selector unit.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc_selector_unit(uvc_device_t *dev,
+					 uvc_device_info_t *info,
+					 const unsigned char *block, size_t block_size) {
+  uvc_selector_unit_t *unit;
+
+  UVC_ENTER();
+
+  unit = calloc(1, sizeof(*unit));
+  unit->bUnitID = block[3];
+
+  DL_APPEND(info->ctrl_if.selector_unit_descs, unit);
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoControl extension unit.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc_extension_unit(uvc_device_t *dev,
+					uvc_device_info_t *info,
+					const unsigned char *block, size_t block_size) {
+  uvc_extension_unit_t *unit = calloc(1, sizeof(*unit));
+  const uint8_t *start_of_controls;
+  int size_of_controls, num_in_pins;
+  int i;
+
+  UVC_ENTER();
+
+  unit->bUnitID = block[3];
+  memcpy(unit->guidExtensionCode, &block[4], 16);
+
+  num_in_pins = block[21];
+  size_of_controls = block[22 + num_in_pins];
+  start_of_controls = &block[23 + num_in_pins];
+
+  for (i = size_of_controls - 1; i >= 0; --i)
+    unit->bmControls = start_of_controls[i] + (unit->bmControls << 8);
+
+  DL_APPEND(info->ctrl_if.extension_unit_descs, unit);
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * Process a single VideoControl descriptor block
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vc(
+    uvc_device_t *dev,
+    uvc_device_info_t *info,
+    const unsigned char *block, size_t block_size) {
+  int descriptor_subtype;
+  uvc_error_t ret = UVC_SUCCESS;
+
+  UVC_ENTER();
+
+  if (block[1] != 36) { // not a CS_INTERFACE descriptor??
+    UVC_EXIT(UVC_SUCCESS);
+    return UVC_SUCCESS; // UVC_ERROR_INVALID_DEVICE;
+  }
+
+  descriptor_subtype = block[2];
+
+  switch (descriptor_subtype) {
+  case UVC_VC_HEADER:
+    ret = uvc_parse_vc_header(dev, info, block, block_size);
+    break;
+  case UVC_VC_INPUT_TERMINAL:
+    ret = uvc_parse_vc_input_terminal(dev, info, block, block_size);
+    break;
+  case UVC_VC_OUTPUT_TERMINAL:
+    break;
+  case UVC_VC_SELECTOR_UNIT:
+    ret = uvc_parse_vc_selector_unit(dev, info, block, block_size);
+    break;
+  case UVC_VC_PROCESSING_UNIT:
+    ret = uvc_parse_vc_processing_unit(dev, info, block, block_size);
+    break;
+  case UVC_VC_EXTENSION_UNIT:
+    ret = uvc_parse_vc_extension_unit(dev, info, block, block_size);
+    break;
+  default:
+    ret = UVC_ERROR_INVALID_DEVICE;
+  }
+
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/** @internal
+ * Process a VideoStreaming interface
+ * @ingroup device
+ */
+uvc_error_t uvc_scan_streaming(uvc_device_t *dev,
+			       uvc_device_info_t *info,
+			       int interface_idx) {
+  const struct libusb_interface_descriptor *if_desc;
+  const unsigned char *buffer;
+  size_t buffer_left, block_size;
+  uvc_error_t ret, parse_ret;
+  uvc_streaming_interface_t *stream_if;
+
+  UVC_ENTER();
+
+  ret = UVC_SUCCESS;
+
+  if_desc = &(info->config->interface[interface_idx].altsetting[0]);
+  buffer = if_desc->extra;
+  buffer_left = if_desc->extra_length;
+
+  stream_if = calloc(1, sizeof(*stream_if));
+  stream_if->parent = info;
+  stream_if->bInterfaceNumber = if_desc->bInterfaceNumber;
+  DL_APPEND(info->stream_ifs, stream_if);
+
+  while (buffer_left >= 3) {
+    block_size = buffer[0];
+    parse_ret = uvc_parse_vs(dev, info, stream_if, buffer, block_size);
+
+    if (parse_ret != UVC_SUCCESS) {
+      ret = parse_ret;
+      break;
+    }
+
+    buffer_left -= block_size;
+    buffer += block_size;
+  }
+
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming header block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_input_header(uvc_streaming_interface_t *stream_if,
+				      const unsigned char *block,
+				      size_t block_size) {
+  UVC_ENTER();
+
+  stream_if->bEndpointAddress = block[6] & 0x8f;
+  stream_if->bTerminalLink = block[8];
+  stream_if->bStillCaptureMethod = block[9];
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming uncompressed format block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_format_uncompressed(uvc_streaming_interface_t *stream_if,
+					     const unsigned char *block,
+					     size_t block_size) {
+  UVC_ENTER();
+
+  uvc_format_desc_t *format = calloc(1, sizeof(*format));
+
+  format->parent = stream_if;
+  format->bDescriptorSubtype = block[2];
+  format->bFormatIndex = block[3];
+  //format->bmCapabilities = block[4];
+  //format->bmFlags = block[5];
+  memcpy(format->guidFormat, &block[5], 16);
+  format->bBitsPerPixel = block[21];
+  format->bDefaultFrameIndex = block[22];
+  format->bAspectRatioX = block[23];
+  format->bAspectRatioY = block[24];
+  format->bmInterlaceFlags = block[25];
+  format->bCopyProtect = block[26];
+
+  DL_APPEND(stream_if->format_descs, format);
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming frame format block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_frame_format(uvc_streaming_interface_t *stream_if,
+					     const unsigned char *block,
+					     size_t block_size) {
+  UVC_ENTER();
+
+  uvc_format_desc_t *format = calloc(1, sizeof(*format));
+
+  format->parent = stream_if;
+  format->bDescriptorSubtype = block[2];
+  format->bFormatIndex = block[3];
+  format->bNumFrameDescriptors = block[4];
+  memcpy(format->guidFormat, &block[5], 16);
+  format->bBitsPerPixel = block[21];
+  format->bDefaultFrameIndex = block[22];
+  format->bAspectRatioX = block[23];
+  format->bAspectRatioY = block[24];
+  format->bmInterlaceFlags = block[25];
+  format->bCopyProtect = block[26];
+  format->bVariableSize = block[27];
+
+  DL_APPEND(stream_if->format_descs, format);
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming MJPEG format block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_format_mjpeg(uvc_streaming_interface_t *stream_if,
+					     const unsigned char *block,
+					     size_t block_size) {
+  UVC_ENTER();
+
+  uvc_format_desc_t *format = calloc(1, sizeof(*format));
+
+  format->parent = stream_if;
+  format->bDescriptorSubtype = block[2];
+  format->bFormatIndex = block[3];
+  memcpy(format->fourccFormat, "MJPG", 4);
+  format->bmFlags = block[5];
+  format->bBitsPerPixel = 0;
+  format->bDefaultFrameIndex = block[6];
+  format->bAspectRatioX = block[7];
+  format->bAspectRatioY = block[8];
+  format->bmInterlaceFlags = block[9];
+  format->bCopyProtect = block[10];
+
+  DL_APPEND(stream_if->format_descs, format);
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming uncompressed frame block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_frame_frame(uvc_streaming_interface_t *stream_if,
+					    const unsigned char *block,
+					    size_t block_size) {
+  uvc_format_desc_t *format;
+  uvc_frame_desc_t *frame;
+
+  const unsigned char *p;
+  int i;
+
+  UVC_ENTER();
+
+  format = stream_if->format_descs->prev;
+  frame = calloc(1, sizeof(*frame));
+
+  frame->parent = format;
+
+  frame->bDescriptorSubtype = block[2];
+  frame->bFrameIndex = block[3];
+  frame->bmCapabilities = block[4];
+  frame->wWidth = block[5] + (block[6] << 8);
+  frame->wHeight = block[7] + (block[8] << 8);
+  frame->dwMinBitRate = DW_TO_INT(&block[9]);
+  frame->dwMaxBitRate = DW_TO_INT(&block[13]);
+  frame->dwDefaultFrameInterval = DW_TO_INT(&block[17]);
+  frame->bFrameIntervalType = block[21];
+  frame->dwBytesPerLine = DW_TO_INT(&block[22]);
+
+  if (block[21] == 0) {
+    frame->dwMinFrameInterval = DW_TO_INT(&block[26]);
+    frame->dwMaxFrameInterval = DW_TO_INT(&block[30]);
+    frame->dwFrameIntervalStep = DW_TO_INT(&block[34]);
+  } else {
+    frame->intervals = calloc(block[21] + 1, sizeof(frame->intervals[0]));
+    p = &block[26];
+
+    for (i = 0; i < block[21]; ++i) {
+      frame->intervals[i] = DW_TO_INT(p);
+      p += 4;
+    }
+    frame->intervals[block[21]] = 0;
+  }
+
+  DL_APPEND(format->frame_descs, frame);
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming uncompressed frame block.
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_frame_uncompressed(uvc_streaming_interface_t *stream_if,
+					    const unsigned char *block,
+					    size_t block_size) {
+  uvc_format_desc_t *format;
+  uvc_frame_desc_t *frame;
+
+  const unsigned char *p;
+  int i;
+
+  UVC_ENTER();
+
+  format = stream_if->format_descs->prev;
+  frame = calloc(1, sizeof(*frame));
+
+  frame->parent = format;
+
+  frame->bDescriptorSubtype = block[2];
+  frame->bFrameIndex = block[3];
+  frame->bmCapabilities = block[4];
+  frame->wWidth = block[5] + (block[6] << 8);
+  frame->wHeight = block[7] + (block[8] << 8);
+  frame->dwMinBitRate = DW_TO_INT(&block[9]);
+  frame->dwMaxBitRate = DW_TO_INT(&block[13]);
+  frame->dwMaxVideoFrameBufferSize = DW_TO_INT(&block[17]);
+  frame->dwDefaultFrameInterval = DW_TO_INT(&block[21]);
+  frame->bFrameIntervalType = block[25];
+
+  if (block[25] == 0) {
+    frame->dwMinFrameInterval = DW_TO_INT(&block[26]);
+    frame->dwMaxFrameInterval = DW_TO_INT(&block[30]);
+    frame->dwFrameIntervalStep = DW_TO_INT(&block[34]);
+  } else {
+    frame->intervals = calloc(block[25] + 1, sizeof(frame->intervals[0]));
+    p = &block[26];
+
+    for (i = 0; i < block[25]; ++i) {
+      frame->intervals[i] = DW_TO_INT(p);
+      p += 4;
+    }
+    frame->intervals[block[25]] = 0;
+  }
+
+  DL_APPEND(format->frame_descs, frame);
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Parse a VideoStreaming still iamge frame
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs_still_image_frame(uvc_streaming_interface_t *stream_if,
+                        const unsigned char *block,
+                        size_t block_size) {
+
+  struct uvc_still_frame_desc* frame;
+  uvc_format_desc_t *format;
+
+  const unsigned char *p;
+  int i;
+
+  UVC_ENTER();
+
+  format = stream_if->format_descs->prev;
+  frame = calloc(1, sizeof(*frame));
+
+  frame->parent = format;
+
+  frame->bDescriptorSubtype = block[2];
+  frame->bEndPointAddress   = block[3];
+  uint8_t numImageSizePatterns = block[4];
+
+  frame->imageSizePatterns = NULL;
+
+  p = &block[5];
+
+  for (i = 1; i <= numImageSizePatterns; ++i) {
+    uvc_still_frame_res_t* res = calloc(1, sizeof(uvc_still_frame_res_t));
+    res->bResolutionIndex = i;
+    res->wWidth = SW_TO_SHORT(p);
+    p += 2;
+    res->wHeight = SW_TO_SHORT(p);
+    p += 2;
+
+    DL_APPEND(frame->imageSizePatterns, res);
+  }
+
+  p = &block[5+4*numImageSizePatterns];
+  frame->bNumCompressionPattern = *p;
+
+  if(frame->bNumCompressionPattern)
+  {
+      frame->bCompression = calloc(frame->bNumCompressionPattern, sizeof(frame->bCompression[0]));
+      for(i = 0; i < frame->bNumCompressionPattern; ++i)
+      {
+          ++p;
+          frame->bCompression[i] = *p;
+      }
+  }
+  else
+  {
+      frame->bCompression = NULL;
+  }
+
+  DL_APPEND(format->still_frame_desc, frame);
+
+  UVC_EXIT(UVC_SUCCESS);
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * Process a single VideoStreaming descriptor block
+ * @ingroup device
+ */
+uvc_error_t uvc_parse_vs(
+    uvc_device_t *dev,
+    uvc_device_info_t *info,
+    uvc_streaming_interface_t *stream_if,
+    const unsigned char *block, size_t block_size) {
+  uvc_error_t ret;
+  int descriptor_subtype;
+
+  UVC_ENTER();
+
+  ret = UVC_SUCCESS;
+  descriptor_subtype = block[2];
+
+  switch (descriptor_subtype) {
+  case UVC_VS_INPUT_HEADER:
+    ret = uvc_parse_vs_input_header(stream_if, block, block_size);
+    break;
+  case UVC_VS_OUTPUT_HEADER:
+    UVC_DEBUG("unsupported descriptor subtype VS_OUTPUT_HEADER");
+    break;
+  case UVC_VS_STILL_IMAGE_FRAME:
+    ret = uvc_parse_vs_still_image_frame(stream_if, block, block_size);
+    break;
+  case UVC_VS_FORMAT_UNCOMPRESSED:
+    ret = uvc_parse_vs_format_uncompressed(stream_if, block, block_size);
+    break;
+  case UVC_VS_FORMAT_MJPEG:
+    ret = uvc_parse_vs_format_mjpeg(stream_if, block, block_size);
+    break;
+  case UVC_VS_FRAME_UNCOMPRESSED:
+  case UVC_VS_FRAME_MJPEG:
+    ret = uvc_parse_vs_frame_uncompressed(stream_if, block, block_size);
+    break;
+  case UVC_VS_FORMAT_MPEG2TS:
+    UVC_DEBUG("unsupported descriptor subtype VS_FORMAT_MPEG2TS");
+    break;
+  case UVC_VS_FORMAT_DV:
+    UVC_DEBUG("unsupported descriptor subtype VS_FORMAT_DV");
+    break;
+  case UVC_VS_COLORFORMAT:
+    UVC_DEBUG("unsupported descriptor subtype VS_COLORFORMAT");
+    break;
+  case UVC_VS_FORMAT_FRAME_BASED:
+    ret = uvc_parse_vs_frame_format ( stream_if, block, block_size );
+    break;
+  case UVC_VS_FRAME_FRAME_BASED:
+    ret = uvc_parse_vs_frame_frame ( stream_if, block, block_size );
+    break;
+  case UVC_VS_FORMAT_STREAM_BASED:
+    UVC_DEBUG("unsupported descriptor subtype VS_FORMAT_STREAM_BASED");
+    break;
+  default:
+    /** @todo handle JPEG and maybe still frames or even DV... */
+    //UVC_DEBUG("unsupported descriptor subtype: %d",descriptor_subtype);
+    break;
+  }
+
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/** @internal
+ * @brief Free memory associated with a UVC device
+ * @pre Streaming must be stopped, and threads must have died
+ */
+void uvc_free_devh(uvc_device_handle_t *devh) {
+  UVC_ENTER();
+
+  if (devh->info)
+    uvc_free_device_info(devh->info);
+
+  if (devh->status_xfer)
+    libusb_free_transfer(devh->status_xfer);
+
+  free(devh);
+
+  UVC_EXIT_VOID();
+}
+
+/** @brief Close a device
+ *
+ * @ingroup device
+ *
+ * Ends any stream that's in progress.
+ *
+ * The device handle and frame structures will be invalidated.
+ */
+void uvc_close(uvc_device_handle_t *devh) {
+  UVC_ENTER();
+  uvc_context_t *ctx = devh->dev->ctx;
+
+  if (devh->streams)
+    uvc_stop_streaming(devh);
+
+  uvc_release_if(devh, devh->info->ctrl_if.bInterfaceNumber);
+
+  /* If we are managing the libusb context and this is the last open device,
+   * then we need to cancel the handler thread. When we call libusb_close,
+   * it'll cause a return from the thread's libusb_handle_events call, after
+   * which the handler thread will check the flag we set and then exit. */
+  if (ctx->own_usb_ctx && ctx->open_devices == devh && devh->next == NULL) {
+    ctx->kill_handler_thread = 1;
+    libusb_close(devh->usb_devh);
+    pthread_join(ctx->handler_thread, NULL);
+  } else {
+    libusb_close(devh->usb_devh);
+  }
+
+  DL_DELETE(ctx->open_devices, devh);
+
+  uvc_unref_device(devh->dev);
+
+  uvc_free_devh(devh);
+
+  UVC_EXIT_VOID();
+}
+
+/** @internal
+ * @brief Get number of open devices
+ */
+size_t uvc_num_devices(uvc_context_t *ctx) {
+  size_t count = 0;
+
+  uvc_device_handle_t *devh;
+
+  UVC_ENTER();
+
+  DL_FOREACH(ctx->open_devices, devh) {
+    count++;
+  }
+
+  UVC_EXIT((int) count);
+  return count;
+}
+
+void uvc_process_control_status(uvc_device_handle_t *devh, unsigned char *data, int len) {
+  enum uvc_status_class status_class;
+  uint8_t originator = 0, selector = 0, event = 0;
+  enum uvc_status_attribute attribute = UVC_STATUS_ATTRIBUTE_UNKNOWN;
+  void *content = NULL;
+  size_t content_len = 0;
+  int found_entity = 0;
+  struct uvc_input_terminal *input_terminal;
+  struct uvc_processing_unit *processing_unit;
+
+  UVC_ENTER();
+
+  if (len < 5) {
+    UVC_DEBUG("Short read of VideoControl status update (%d bytes)", len);
+    UVC_EXIT_VOID();
+    return;
+  }
+
+  originator = data[1];
+  event = data[2];
+  selector = data[3];
+
+  if (originator == 0) {
+    UVC_DEBUG("Unhandled update from VC interface");
+    UVC_EXIT_VOID();
+    return;  /* @todo VideoControl virtual entity interface updates */
+  }
+
+  if (event != 0) {
+    UVC_DEBUG("Unhandled VC event %d", (int) event);
+    UVC_EXIT_VOID();
+    return;
+  }
+
+  /* printf("bSelector: %d\n", selector); */
+
+  DL_FOREACH(devh->info->ctrl_if.input_term_descs, input_terminal) {
+    if (input_terminal->bTerminalID == originator) {
+      status_class = UVC_STATUS_CLASS_CONTROL_CAMERA;
+      found_entity = 1;
+      break;
+    }
+  }
+
+  if (!found_entity) {
+    DL_FOREACH(devh->info->ctrl_if.processing_unit_descs, processing_unit) {
+      if (processing_unit->bUnitID == originator) {
+        status_class = UVC_STATUS_CLASS_CONTROL_PROCESSING;
+        found_entity = 1;
+        break;
+      }
+    }
+  }
+
+  if (!found_entity) {
+    UVC_DEBUG("Got status update for unknown VideoControl entity %d",
+  (int) originator);
+    UVC_EXIT_VOID();
+    return;
+  }
+
+  attribute = data[4];
+  content = data + 5;
+  content_len = len - 5;
+
+  UVC_DEBUG("Event: class=%d, event=%d, selector=%d, attribute=%d, content_len=%zd",
+    status_class, event, selector, attribute, content_len);
+
+  if(devh->status_cb) {
+    UVC_DEBUG("Running user-supplied status callback");
+    devh->status_cb(status_class,
+                    event,
+                    selector,
+                    attribute,
+                    content, content_len,
+                    devh->status_user_ptr);
+  }
+  
+  UVC_EXIT_VOID();
+}
+
+void uvc_process_streaming_status(uvc_device_handle_t *devh, unsigned char *data, int len) {
+  
+  UVC_ENTER();
+
+  if (len < 3) {
+    UVC_DEBUG("Invalid streaming status event received.\n");
+    UVC_EXIT_VOID();
+    return;
+  }
+
+  if (data[2] == 0) {
+    if (len < 4) {
+      UVC_DEBUG("Short read of status update (%d bytes)", len);
+      UVC_EXIT_VOID();
+      return;
+    }
+    UVC_DEBUG("Button (intf %u) %s len %d\n", data[1], data[3] ? "pressed" : "released", len);
+    
+    if(devh->button_cb) {
+      UVC_DEBUG("Running user-supplied button callback");
+      devh->button_cb(data[1],
+                      data[3],
+                      devh->button_user_ptr);
+    }
+  } else {
+    UVC_DEBUG("Stream %u error event %02x %02x len %d.\n", data[1], data[2], data[3], len);
+  }
+
+  UVC_EXIT_VOID();
+}
+
+void uvc_process_status_xfer(uvc_device_handle_t *devh, struct libusb_transfer *transfer) {
+  
+  UVC_ENTER();
+
+  /* printf("Got transfer of aLen = %d\n", transfer->actual_length); */
+
+  if (transfer->actual_length > 0) {
+    switch (transfer->buffer[0] & 0x0f) {
+    case 1: /* VideoControl interface */
+      uvc_process_control_status(devh, transfer->buffer, transfer->actual_length);
+      break;
+    case 2:  /* VideoStreaming interface */
+      uvc_process_streaming_status(devh, transfer->buffer, transfer->actual_length);
+      break;
+    }
+  }
+
+  UVC_EXIT_VOID();
+}
+
+/** @internal
+ * @brief Process asynchronous status updates from the device.
+ */
+void LIBUSB_CALL _uvc_status_callback(struct libusb_transfer *transfer) {
+  UVC_ENTER();
+
+  uvc_device_handle_t *devh = (uvc_device_handle_t *) transfer->user_data;
+
+  switch (transfer->status) {
+  case LIBUSB_TRANSFER_ERROR:
+  case LIBUSB_TRANSFER_CANCELLED:
+  case LIBUSB_TRANSFER_NO_DEVICE:
+    UVC_DEBUG("not processing/resubmitting, status = %d", transfer->status);
+    UVC_EXIT_VOID();
+    return;
+  case LIBUSB_TRANSFER_COMPLETED:
+    uvc_process_status_xfer(devh, transfer);
+    break;
+  case LIBUSB_TRANSFER_TIMED_OUT:
+  case LIBUSB_TRANSFER_STALL:
+  case LIBUSB_TRANSFER_OVERFLOW:
+    UVC_DEBUG("retrying transfer, status = %d", transfer->status);
+    break;
+  }
+
+#ifdef UVC_DEBUGGING
+  uvc_error_t ret =
+#endif
+      libusb_submit_transfer(transfer);
+  UVC_DEBUG("libusb_submit_transfer() = %d", ret);
+
+  UVC_EXIT_VOID();
+}
+
+/** @brief Set a callback function to receive status updates
+ *
+ * @ingroup device
+ */
+void uvc_set_status_callback(uvc_device_handle_t *devh,
+                             uvc_status_callback_t cb,
+                             void *user_ptr) {
+  UVC_ENTER();
+
+  devh->status_cb = cb;
+  devh->status_user_ptr = user_ptr;
+
+  UVC_EXIT_VOID();
+}
+
+/** @brief Set a callback function to receive button events
+ *
+ * @ingroup device
+ */
+void uvc_set_button_callback(uvc_device_handle_t *devh,
+                             uvc_button_callback_t cb,
+                             void *user_ptr) {
+  UVC_ENTER();
+
+  devh->button_cb = cb;
+  devh->button_user_ptr = user_ptr;
+
+  UVC_EXIT_VOID();
+}
+
+/**
+ * @brief Get format descriptions for the open device.
+ *
+ * @note Do not modify the returned structure.
+ *
+ * @param devh Device handle to an open UVC device
+ */
+const uvc_format_desc_t *uvc_get_format_descs(uvc_device_handle_t *devh) {
+  return devh->info->stream_ifs->format_descs;
+}

collector/core/gripper/camera_service_src/third_party/libuvc/src/diag.c

@@ -0,0 +1,376 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+/**
+ * @defgroup diag Diagnostics
+ * @brief Interpretation of devices, error codes and negotiated stream parameters
+ */
+
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+/** @internal */
+typedef struct _uvc_error_msg {
+  uvc_error_t err;
+  const char *msg;
+} _uvc_error_msg_t;
+
+static const _uvc_error_msg_t uvc_error_msgs[] = {
+  {UVC_SUCCESS, "Success"},
+  {UVC_ERROR_IO, "I/O error"},
+  {UVC_ERROR_INVALID_PARAM, "Invalid parameter"},
+  {UVC_ERROR_ACCESS, "Access denied"},
+  {UVC_ERROR_NO_DEVICE, "No such device"},
+  {UVC_ERROR_NOT_FOUND, "Not found"},
+  {UVC_ERROR_BUSY, "Busy"},
+  {UVC_ERROR_TIMEOUT, "Timeout"},
+  {UVC_ERROR_OVERFLOW, "Overflow"},
+  {UVC_ERROR_PIPE, "Pipe"},
+  {UVC_ERROR_INTERRUPTED, "Interrupted"},
+  {UVC_ERROR_NO_MEM, "Out of memory"},
+  {UVC_ERROR_NOT_SUPPORTED, "Not supported"},
+  {UVC_ERROR_INVALID_DEVICE, "Invalid device"},
+  {UVC_ERROR_INVALID_MODE, "Invalid mode"},
+  {UVC_ERROR_CALLBACK_EXISTS, "Callback exists"}
+};
+
+/** @brief Print a message explaining an error in the UVC driver
+ * @ingroup diag
+ *
+ * @param err UVC error code
+ * @param msg Optional custom message, prepended to output
+ */
+void uvc_perror(uvc_error_t err, const char *msg) {
+  if (msg && *msg) {
+    fputs(msg, stderr);
+    fputs(": ", stderr);
+  }
+
+  fprintf(stderr, "%s (%d)\n", uvc_strerror(err), err);
+}
+
+/** @brief Return a string explaining an error in the UVC driver
+ * @ingroup diag
+ *
+ * @param err UVC error code
+ * @return error message
+ */
+const char* uvc_strerror(uvc_error_t err) {
+  size_t idx;
+
+  for (idx = 0; idx < sizeof(uvc_error_msgs) / sizeof(*uvc_error_msgs); ++idx) {
+    if (uvc_error_msgs[idx].err == err) {
+      return uvc_error_msgs[idx].msg;
+    }
+  }
+
+  return "Unknown error";
+}
+
+/** @brief Print the values in a stream control block
+ * @ingroup diag
+ *
+ * @param devh UVC device
+ * @param stream Output stream (stderr if NULL)
+ */
+void uvc_print_stream_ctrl(uvc_stream_ctrl_t *ctrl, FILE *stream) {
+  if (stream == NULL)
+    stream = stderr;
+
+  fprintf(stream, "bmHint: %04x\n", ctrl->bmHint);
+  fprintf(stream, "bFormatIndex: %d\n", ctrl->bFormatIndex);
+  fprintf(stream, "bFrameIndex: %d\n", ctrl->bFrameIndex);
+  fprintf(stream, "dwFrameInterval: %u\n", ctrl->dwFrameInterval);
+  fprintf(stream, "wKeyFrameRate: %d\n", ctrl->wKeyFrameRate);
+  fprintf(stream, "wPFrameRate: %d\n", ctrl->wPFrameRate);
+  fprintf(stream, "wCompQuality: %d\n", ctrl->wCompQuality);
+  fprintf(stream, "wCompWindowSize: %d\n", ctrl->wCompWindowSize);
+  fprintf(stream, "wDelay: %d\n", ctrl->wDelay);
+  fprintf(stream, "dwMaxVideoFrameSize: %u\n", ctrl->dwMaxVideoFrameSize);
+  fprintf(stream, "dwMaxPayloadTransferSize: %u\n", ctrl->dwMaxPayloadTransferSize);
+  fprintf(stream, "bInterfaceNumber: %d\n", ctrl->bInterfaceNumber);
+}
+
+static const char *_uvc_name_for_format_subtype(uint8_t subtype) {
+  switch (subtype) {
+  case UVC_VS_FORMAT_UNCOMPRESSED:
+    return "UncompressedFormat";
+  case UVC_VS_FORMAT_MJPEG:
+    return "MJPEGFormat";
+  case UVC_VS_FORMAT_FRAME_BASED:
+    return "FrameFormat";
+  default:
+    return "Unknown";
+  }
+}
+
+/** @brief Print camera capabilities and configuration.
+ * @ingroup diag
+ *
+ * @param devh UVC device
+ * @param stream Output stream (stderr if NULL)
+ */
+void uvc_print_diag(uvc_device_handle_t *devh, FILE *stream) {
+  if (stream == NULL)
+    stream = stderr;
+
+  if (devh->info->ctrl_if.bcdUVC) {
+    uvc_streaming_interface_t *stream_if;
+    int stream_idx = 0;
+
+    uvc_device_descriptor_t *desc;
+    uvc_get_device_descriptor(devh->dev, &desc);
+
+    fprintf(stream, "DEVICE CONFIGURATION (%04x:%04x/%s) ---\n",
+        desc->idVendor, desc->idProduct,
+        desc->serialNumber ? desc->serialNumber : "[none]");
+
+    uvc_free_device_descriptor(desc);
+
+    fprintf(stream, "Status: %s\n", devh->streams ? "streaming" : "idle");
+
+    fprintf(stream, "VideoControl:\n"
+        "\tbcdUVC: 0x%04x\n",
+        devh->info->ctrl_if.bcdUVC);
+
+    DL_FOREACH(devh->info->stream_ifs, stream_if) {
+      uvc_format_desc_t *fmt_desc;
+
+      ++stream_idx;
+
+      fprintf(stream, "VideoStreaming(%d):\n"
+          "\tbEndpointAddress: %d\n\tFormats:\n",
+          stream_idx, stream_if->bEndpointAddress);
+
+      DL_FOREACH(stream_if->format_descs, fmt_desc) {
+        uvc_frame_desc_t *frame_desc;
+        int i;
+
+        switch (fmt_desc->bDescriptorSubtype) {
+          case UVC_VS_FORMAT_UNCOMPRESSED:
+          case UVC_VS_FORMAT_MJPEG:
+          case UVC_VS_FORMAT_FRAME_BASED:
+            fprintf(stream,
+                "\t\%s(%d)\n"
+                "\t\t  bits per pixel: %d\n"
+                "\t\t  GUID: ",
+                _uvc_name_for_format_subtype(fmt_desc->bDescriptorSubtype),
+                fmt_desc->bFormatIndex,
+                fmt_desc->bBitsPerPixel);
+
+            for (i = 0; i < 16; ++i)
+              fprintf(stream, "%02x", fmt_desc->guidFormat[i]);
+
+            fprintf(stream, " (%4s)\n", fmt_desc->fourccFormat );
+
+            fprintf(stream,
+                "\t\t  default frame: %d\n"
+                "\t\t  aspect ratio: %dx%d\n"
+                "\t\t  interlace flags: %02x\n"
+                "\t\t  copy protect: %02x\n",
+                fmt_desc->bDefaultFrameIndex,
+                fmt_desc->bAspectRatioX,
+                fmt_desc->bAspectRatioY,
+                fmt_desc->bmInterlaceFlags,
+                fmt_desc->bCopyProtect);
+
+            DL_FOREACH(fmt_desc->frame_descs, frame_desc) {
+              uint32_t *interval_ptr;
+
+              fprintf(stream,
+                  "\t\t\tFrameDescriptor(%d)\n"
+                  "\t\t\t  capabilities: %02x\n"
+                  "\t\t\t  size: %dx%d\n"
+                  "\t\t\t  bit rate: %d-%d\n"
+                  "\t\t\t  max frame size: %d\n"
+                  "\t\t\t  default interval: 1/%d\n",
+                  frame_desc->bFrameIndex,
+                  frame_desc->bmCapabilities,
+                  frame_desc->wWidth,
+                  frame_desc->wHeight,
+                  frame_desc->dwMinBitRate,
+                  frame_desc->dwMaxBitRate,
+                  frame_desc->dwMaxVideoFrameBufferSize,
+                  10000000 / frame_desc->dwDefaultFrameInterval);
+              if (frame_desc->intervals) {
+                for (interval_ptr = frame_desc->intervals;
+                     *interval_ptr;
+                     ++interval_ptr) {
+                  fprintf(stream,
+                      "\t\t\t  interval[%d]: 1/%d\n",
+		      (int) (interval_ptr - frame_desc->intervals),
+		      10000000 / *interval_ptr);
+                }
+              } else {
+                fprintf(stream,
+                    "\t\t\t  min interval[%d] = 1/%d\n"
+                    "\t\t\t  max interval[%d] = 1/%d\n",
+                    frame_desc->dwMinFrameInterval,
+                    10000000 / frame_desc->dwMinFrameInterval,
+                    frame_desc->dwMaxFrameInterval,
+                    10000000 / frame_desc->dwMaxFrameInterval);
+                if (frame_desc->dwFrameIntervalStep)
+                  fprintf(stream,
+                      "\t\t\t  interval step[%d] = 1/%d\n",
+                      frame_desc->dwFrameIntervalStep,
+                      10000000 / frame_desc->dwFrameIntervalStep);
+              }
+            }
+            if(fmt_desc->still_frame_desc)
+            {
+                uvc_still_frame_desc_t* still_frame_desc;
+                DL_FOREACH(fmt_desc->still_frame_desc, still_frame_desc)
+                {
+                    fprintf(stream,
+                        "\t\t\tStillFrameDescriptor\n"
+                        "\t\t\t  bEndPointAddress: %02x\n",
+                        still_frame_desc->bEndPointAddress);
+                    uvc_still_frame_res_t* imageSizePattern;
+                    DL_FOREACH(still_frame_desc->imageSizePatterns, imageSizePattern) {
+                        fprintf(stream,
+                            "\t\t\t  wWidth(%d) = %d\n"
+                            "\t\t\t  wHeight(%d) = %d\n",
+                            imageSizePattern->bResolutionIndex,
+                            imageSizePattern->wWidth,
+                            imageSizePattern->bResolutionIndex,
+                            imageSizePattern->wHeight);
+                    }
+                }
+            }
+            break;
+          default:
+            fprintf(stream, "\t-UnknownFormat (%d)\n",
+                fmt_desc->bDescriptorSubtype );
+        }
+      }
+    }
+
+    fprintf(stream, "END DEVICE CONFIGURATION\n");
+  } else {
+    fprintf(stream, "uvc_print_diag: Device not configured!\n");
+  }
+}
+
+/** @brief Print all possible frame configuration.
+ * @ingroup diag
+ *
+ * @param devh UVC device
+ * @param stream Output stream (stderr if NULL)
+ */
+void uvc_print_frameformats(uvc_device_handle_t *devh) {
+
+  if (devh->info->ctrl_if.bcdUVC) {
+    uvc_streaming_interface_t *stream_if;
+    int stream_idx = 0;
+    DL_FOREACH(devh->info->stream_ifs, stream_if) {
+      uvc_format_desc_t *fmt_desc;
+      ++stream_idx;
+
+      DL_FOREACH(stream_if->format_descs, fmt_desc) {
+        uvc_frame_desc_t *frame_desc;
+        int i;
+
+        switch (fmt_desc->bDescriptorSubtype) {
+          case UVC_VS_FORMAT_UNCOMPRESSED:
+          case UVC_VS_FORMAT_MJPEG:
+          case UVC_VS_FORMAT_FRAME_BASED:
+            printf("         \%s(%d)\n"
+                "            bits per pixel: %d\n"
+                "            GUID: ",
+                _uvc_name_for_format_subtype(fmt_desc->bDescriptorSubtype),
+                fmt_desc->bFormatIndex,
+                fmt_desc->bBitsPerPixel);
+
+            for (i = 0; i < 16; ++i)
+              printf("%02x", fmt_desc->guidFormat[i]);
+
+            printf(" (%4s)\n", fmt_desc->fourccFormat );
+
+            printf("            default frame: %d\n"
+                "            aspect ratio: %dx%d\n"
+                "            interlace flags: %02x\n"
+                "            copy protect: %02x\n",
+                fmt_desc->bDefaultFrameIndex,
+                fmt_desc->bAspectRatioX,
+                fmt_desc->bAspectRatioY,
+                fmt_desc->bmInterlaceFlags,
+                fmt_desc->bCopyProtect);
+
+            DL_FOREACH(fmt_desc->frame_descs, frame_desc) {
+              uint32_t *interval_ptr;
+
+              printf("               FrameDescriptor(%d)\n"
+                  "                  capabilities: %02x\n"
+                  "                  size: %dx%d\n"
+                  "                  bit rate: %d-%d\n"
+                  "                  max frame size: %d\n"
+                  "                  default interval: 1/%d\n",
+                  frame_desc->bFrameIndex,
+                  frame_desc->bmCapabilities,
+                  frame_desc->wWidth,
+                  frame_desc->wHeight,
+                  frame_desc->dwMinBitRate,
+                  frame_desc->dwMaxBitRate,
+                  frame_desc->dwMaxVideoFrameBufferSize,
+                  10000000 / frame_desc->dwDefaultFrameInterval);
+              if (frame_desc->intervals) {
+                for (interval_ptr = frame_desc->intervals;
+                     *interval_ptr;
+                     ++interval_ptr) {
+                  printf("                  interval[%d]: 1/%d\n",
+		      (int) (interval_ptr - frame_desc->intervals),
+		      10000000 / *interval_ptr);
+                }
+              } else {
+                printf("                  min interval[%d] = 1/%d\n"
+                    "                  max interval[%d] = 1/%d\n",
+                    frame_desc->dwMinFrameInterval,
+                    10000000 / frame_desc->dwMinFrameInterval,
+                    frame_desc->dwMaxFrameInterval,
+                    10000000 / frame_desc->dwMaxFrameInterval);
+                if (frame_desc->dwFrameIntervalStep)
+                  printf("                  interval step[%d] = 1/%d\n",
+                      frame_desc->dwFrameIntervalStep,
+                      10000000 / frame_desc->dwFrameIntervalStep);
+              }
+            }
+            break;
+          default:
+            printf("\t-UnknownFormat (%d)\n",fmt_desc->bDescriptorSubtype );
+        }
+      }
+    }
+  } else {
+    printf("uvc_print_frameformats: Device not configured!\n");
+  }
+}

collector/core/gripper/camera_service_src/third_party/libuvc/src/example.c

@@ -0,0 +1,226 @@
+#include "libuvc/libuvc.h"
+#include <stdio.h>
+#include <unistd.h>
+
+/* This callback function runs once per frame. Use it to perform any
+ * quick processing you need, or have it put the frame into your application's
+ * input queue. If this function takes too long, you'll start losing frames. */
+void cb(uvc_frame_t *frame, void *ptr) {
+  uvc_frame_t *bgr;
+  uvc_error_t ret;
+  enum uvc_frame_format *frame_format = (enum uvc_frame_format *)ptr;
+  /* FILE *fp;
+   * static int jpeg_count = 0;
+   * static const char *H264_FILE = "iOSDevLog.h264";
+   * static const char *MJPEG_FILE = ".jpeg";
+   * char filename[16]; */
+
+  /* We'll convert the image from YUV/JPEG to BGR, so allocate space */
+  bgr = uvc_allocate_frame(frame->width * frame->height * 3);
+  if (!bgr) {
+    printf("unable to allocate bgr frame!\n");
+    return;
+  }
+
+  printf("callback! frame_format = %d, width = %d, height = %d, length = %lu, ptr = %p\n",
+    frame->frame_format, frame->width, frame->height, frame->data_bytes, ptr);
+
+  switch (frame->frame_format) {
+  case UVC_FRAME_FORMAT_H264:
+    /* use `ffplay H264_FILE` to play */
+    /* fp = fopen(H264_FILE, "a");
+     * fwrite(frame->data, 1, frame->data_bytes, fp);
+     * fclose(fp); */
+    break;
+  case UVC_COLOR_FORMAT_MJPEG:
+    /* sprintf(filename, "%d%s", jpeg_count++, MJPEG_FILE);
+     * fp = fopen(filename, "w");
+     * fwrite(frame->data, 1, frame->data_bytes, fp);
+     * fclose(fp); */
+    break;
+  case UVC_COLOR_FORMAT_YUYV:
+    /* Do the BGR conversion */
+    ret = uvc_any2bgr(frame, bgr);
+    if (ret) {
+      uvc_perror(ret, "uvc_any2bgr");
+      uvc_free_frame(bgr);
+      return;
+    }
+    break;
+  default:
+    break;
+  }
+
+  if (frame->sequence % 30 == 0) {
+    printf(" * got image %u\n",  frame->sequence);
+  }
+
+  /* Call a user function:
+   *
+   * my_type *my_obj = (*my_type) ptr;
+   * my_user_function(ptr, bgr);
+   * my_other_function(ptr, bgr->data, bgr->width, bgr->height);
+   */
+
+  /* Call a C++ method:
+   *
+   * my_type *my_obj = (*my_type) ptr;
+   * my_obj->my_func(bgr);
+   */
+
+  /* Use opencv.highgui to display the image:
+   * 
+   * cvImg = cvCreateImageHeader(
+   *     cvSize(bgr->width, bgr->height),
+   *     IPL_DEPTH_8U,
+   *     3);
+   *
+   * cvSetData(cvImg, bgr->data, bgr->width * 3); 
+   *
+   * cvNamedWindow("Test", CV_WINDOW_AUTOSIZE);
+   * cvShowImage("Test", cvImg);
+   * cvWaitKey(10);
+   *
+   * cvReleaseImageHeader(&cvImg);
+   */
+
+  uvc_free_frame(bgr);
+}
+
+int main(int argc, char **argv) {
+  uvc_context_t *ctx;
+  uvc_device_t *dev;
+  uvc_device_handle_t *devh;
+  uvc_stream_ctrl_t ctrl;
+  uvc_error_t res;
+
+  /* Initialize a UVC service context. Libuvc will set up its own libusb
+   * context. Replace NULL with a libusb_context pointer to run libuvc
+   * from an existing libusb context. */
+  res = uvc_init(&ctx, NULL);
+
+  if (res < 0) {
+    uvc_perror(res, "uvc_init");
+    return res;
+  }
+
+  puts("UVC initialized");
+
+  /* Locates the first attached UVC device, stores in dev */
+  res = uvc_find_device(
+      ctx, &dev,
+      0, 0, NULL); /* filter devices: vendor_id, product_id, "serial_num" */
+
+  if (res < 0) {
+    uvc_perror(res, "uvc_find_device"); /* no devices found */
+  } else {
+    puts("Device found");
+
+    /* Try to open the device: requires exclusive access */
+    res = uvc_open(dev, &devh);
+
+    if (res < 0) {
+      uvc_perror(res, "uvc_open"); /* unable to open device */
+    } else {
+      puts("Device opened");
+
+      /* Print out a message containing all the information that libuvc
+       * knows about the device */
+      uvc_print_diag(devh, stderr);
+
+      const uvc_format_desc_t *format_desc = uvc_get_format_descs(devh);
+      const uvc_frame_desc_t *frame_desc = format_desc->frame_descs;
+      enum uvc_frame_format frame_format;
+      int width = 640;
+      int height = 480;
+      int fps = 30;
+
+      switch (format_desc->bDescriptorSubtype) {
+      case UVC_VS_FORMAT_MJPEG:
+        frame_format = UVC_COLOR_FORMAT_MJPEG;
+        break;
+      case UVC_VS_FORMAT_FRAME_BASED:
+        frame_format = UVC_FRAME_FORMAT_H264;
+        break;
+      default:
+        frame_format = UVC_FRAME_FORMAT_YUYV;
+        break;
+      }
+
+      if (frame_desc) {
+        width = frame_desc->wWidth;
+        height = frame_desc->wHeight;
+        fps = 10000000 / frame_desc->dwDefaultFrameInterval;
+      }
+
+      printf("\nFirst format: (%4s) %dx%d %dfps\n", format_desc->fourccFormat, width, height, fps);
+
+      /* Try to negotiate first stream profile */
+      res = uvc_get_stream_ctrl_format_size(
+          devh, &ctrl, /* result stored in ctrl */
+          frame_format,
+          width, height, fps /* width, height, fps */
+      );
+
+      /* Print out the result */
+      uvc_print_stream_ctrl(&ctrl, stderr);
+
+      if (res < 0) {
+        uvc_perror(res, "get_mode"); /* device doesn't provide a matching stream */
+      } else {
+        /* Start the video stream. The library will call user function cb:
+         *   cb(frame, (void *) 12345)
+         */
+        res = uvc_start_streaming(devh, &ctrl, cb, (void *) 12345, 0);
+
+        if (res < 0) {
+          uvc_perror(res, "start_streaming"); /* unable to start stream */
+        } else {
+          puts("Streaming...");
+
+          /* enable auto exposure - see uvc_set_ae_mode documentation */
+          puts("Enabling auto exposure ...");
+          const uint8_t UVC_AUTO_EXPOSURE_MODE_AUTO = 2;
+          res = uvc_set_ae_mode(devh, UVC_AUTO_EXPOSURE_MODE_AUTO);
+          if (res == UVC_SUCCESS) {
+            puts(" ... enabled auto exposure");
+          } else if (res == UVC_ERROR_PIPE) {
+            /* this error indicates that the camera does not support the full AE mode;
+             * try again, using aperture priority mode (fixed aperture, variable exposure time) */
+            puts(" ... full AE not supported, trying aperture priority mode");
+            const uint8_t UVC_AUTO_EXPOSURE_MODE_APERTURE_PRIORITY = 8;
+            res = uvc_set_ae_mode(devh, UVC_AUTO_EXPOSURE_MODE_APERTURE_PRIORITY);
+            if (res < 0) {
+              uvc_perror(res, " ... uvc_set_ae_mode failed to enable aperture priority mode");
+            } else {
+              puts(" ... enabled aperture priority auto exposure mode");
+            }
+          } else {
+            uvc_perror(res, " ... uvc_set_ae_mode failed to enable auto exposure mode");
+          }
+
+          sleep(10); /* stream for 10 seconds */
+
+          /* End the stream. Blocks until last callback is serviced */
+          uvc_stop_streaming(devh);
+          puts("Done streaming.");
+        }
+      }
+
+      /* Release our handle on the device */
+      uvc_close(devh);
+      puts("Device closed");
+    }
+
+    /* Release the device descriptor */
+    uvc_unref_device(dev);
+  }
+
+  /* Close the UVC context. This closes and cleans up any existing device handles,
+   * and it closes the libusb context if one was not provided. */
+  uvc_exit(ctx);
+  puts("UVC exited");
+
+  return 0;
+}
+

collector/core/gripper/camera_service_src/third_party/libuvc/src/frame-mjpeg.c

@@ -0,0 +1,222 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2014 Robert Xiao
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+
+/**
+ * @defgroup frame Frame processing
+ */
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+#include <jpeglib.h>
+#include <setjmp.h>
+
+extern uvc_error_t uvc_ensure_frame_size(uvc_frame_t *frame, size_t need_bytes);
+
+struct error_mgr {
+  struct jpeg_error_mgr super;
+  jmp_buf jmp;
+};
+
+static void _error_exit(j_common_ptr dinfo) {
+  struct error_mgr *myerr = (struct error_mgr *)dinfo->err;
+  (*dinfo->err->output_message)(dinfo);
+  longjmp(myerr->jmp, 1);
+}
+
+/* ISO/IEC 10918-1:1993(E) K.3.3. Default Huffman tables used by MJPEG UVC devices
+   which don't specify a Huffman table in the JPEG stream. */
+static const unsigned char dc_lumi_len[] = 
+  {0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0};
+static const unsigned char dc_lumi_val[] = 
+  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+
+static const unsigned char dc_chromi_len[] = 
+  {0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0};
+static const unsigned char dc_chromi_val[] = 
+  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+
+static const unsigned char ac_lumi_len[] = 
+  {0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d};
+static const unsigned char ac_lumi_val[] = 
+  {0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21,
+   0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71,
+   0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1,
+   0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72,
+   0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25,
+   0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37,
+   0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
+   0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83,
+   0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93,
+   0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3,
+   0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3,
+   0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3,
+   0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1,
+   0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa};
+static const unsigned char ac_chromi_len[] = 
+  {0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77};
+static const unsigned char ac_chromi_val[] = 
+  {0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31,
+   0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22,
+   0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1,
+   0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1,
+   0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18,
+   0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36,
+   0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47,
+   0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
+   0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
+   0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a,
+   0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa,
+   0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba,
+   0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca,
+   0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+   0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa};
+
+#define COPY_HUFF_TABLE(dinfo,tbl,name) do { \
+  if(dinfo->tbl == NULL) dinfo->tbl = jpeg_alloc_huff_table((j_common_ptr)dinfo); \
+  memcpy(dinfo->tbl->bits, name##_len, sizeof(name##_len)); \
+  memset(dinfo->tbl->huffval, 0, sizeof(dinfo->tbl->huffval)); \
+  memcpy(dinfo->tbl->huffval, name##_val, sizeof(name##_val)); \
+} while(0)
+
+static void insert_huff_tables(j_decompress_ptr dinfo) {
+  COPY_HUFF_TABLE(dinfo, dc_huff_tbl_ptrs[0], dc_lumi);
+  COPY_HUFF_TABLE(dinfo, dc_huff_tbl_ptrs[1], dc_chromi);
+  COPY_HUFF_TABLE(dinfo, ac_huff_tbl_ptrs[0], ac_lumi);
+  COPY_HUFF_TABLE(dinfo, ac_huff_tbl_ptrs[1], ac_chromi);
+}
+
+static uvc_error_t uvc_mjpeg_convert(uvc_frame_t *in, uvc_frame_t *out) {
+  struct jpeg_decompress_struct dinfo;
+  struct error_mgr jerr;
+  size_t lines_read;
+  dinfo.err = jpeg_std_error(&jerr.super);
+  jerr.super.error_exit = _error_exit;
+
+  if (setjmp(jerr.jmp)) {
+    goto fail;
+  }
+
+  jpeg_create_decompress(&dinfo);
+  jpeg_mem_src(&dinfo, in->data, in->data_bytes);
+  jpeg_read_header(&dinfo, TRUE);
+
+  if (dinfo.dc_huff_tbl_ptrs[0] == NULL) {
+    /* This frame is missing the Huffman tables: fill in the standard ones */
+    insert_huff_tables(&dinfo);
+  }
+
+  if (out->frame_format == UVC_FRAME_FORMAT_RGB)
+    dinfo.out_color_space = JCS_RGB;
+  else if (out->frame_format == UVC_FRAME_FORMAT_GRAY8)
+    dinfo.out_color_space = JCS_GRAYSCALE;
+  else
+    goto fail;
+
+  dinfo.dct_method = JDCT_IFAST;
+
+  jpeg_start_decompress(&dinfo);
+
+  lines_read = 0;
+  while (dinfo.output_scanline < dinfo.output_height) {
+    unsigned char *buffer[1] = {( unsigned char*) out->data + lines_read * out->step };
+    int num_scanlines;
+
+    num_scanlines = jpeg_read_scanlines(&dinfo, buffer, 1);
+    lines_read += num_scanlines;
+  }
+
+  jpeg_finish_decompress(&dinfo);
+  jpeg_destroy_decompress(&dinfo);
+  return 0;
+
+fail:
+  jpeg_destroy_decompress(&dinfo);
+  return UVC_ERROR_OTHER;
+}
+
+/** @brief Convert an MJPEG frame to RGB
+ * @ingroup frame
+ *
+ * @param in MJPEG frame
+ * @param out RGB frame
+ */
+uvc_error_t uvc_mjpeg2rgb(uvc_frame_t *in, uvc_frame_t *out) {
+  if (in->frame_format != UVC_FRAME_FORMAT_MJPEG)
+    return UVC_ERROR_INVALID_PARAM;
+
+  if (uvc_ensure_frame_size(out, in->width * in->height * 3) < 0)
+    return UVC_ERROR_NO_MEM;
+
+  out->width = in->width;
+  out->height = in->height;
+  out->frame_format = UVC_FRAME_FORMAT_RGB;
+  out->step = in->width * 3;
+  out->sequence = in->sequence;
+  out->capture_time = in->capture_time;
+  out->capture_time_finished = in->capture_time_finished;
+  out->source = in->source;
+
+  return uvc_mjpeg_convert(in, out);
+}
+
+/** @brief Convert an MJPEG frame to GRAY8
+ * @ingroup frame
+ *
+ * @param in MJPEG frame
+ * @param out GRAY8 frame
+ */
+uvc_error_t uvc_mjpeg2gray(uvc_frame_t *in, uvc_frame_t *out) {
+  if (in->frame_format != UVC_FRAME_FORMAT_MJPEG)
+    return UVC_ERROR_INVALID_PARAM;
+
+  if (uvc_ensure_frame_size(out, in->width * in->height) < 0)
+    return UVC_ERROR_NO_MEM;
+
+  out->width = in->width;
+  out->height = in->height;
+  out->frame_format = UVC_FRAME_FORMAT_GRAY8;
+  out->step = in->width;
+  out->sequence = in->sequence;
+  out->capture_time = in->capture_time;
+  out->capture_time_finished = in->capture_time_finished;
+  out->source = in->source;
+
+  return uvc_mjpeg_convert(in, out);
+}

collector/core/gripper/camera_service_src/third_party/libuvc/src/frame.c

@@ -0,0 +1,475 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+/**
+ * @defgroup frame Frame processing
+ * @brief Tools for managing frame buffers and converting between image formats
+ */
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+/** @internal */
+uvc_error_t uvc_ensure_frame_size(uvc_frame_t *frame, size_t need_bytes) {
+  if (frame->library_owns_data) {
+    if (!frame->data || frame->data_bytes != need_bytes) {
+      frame->data_bytes = need_bytes;
+      frame->data = realloc(frame->data, frame->data_bytes);
+    }
+    if (!frame->data)
+      return UVC_ERROR_NO_MEM;
+    return UVC_SUCCESS;
+  } else {
+    if (!frame->data || frame->data_bytes < need_bytes)
+      return UVC_ERROR_NO_MEM;
+    return UVC_SUCCESS;
+  }
+}
+
+/** @brief Allocate a frame structure
+ * @ingroup frame
+ *
+ * @param data_bytes Number of bytes to allocate, or zero
+ * @return New frame, or NULL on error
+ */
+uvc_frame_t *uvc_allocate_frame(size_t data_bytes) {
+  uvc_frame_t *frame = malloc(sizeof(*frame));
+
+  if (!frame)
+    return NULL;
+
+  memset(frame, 0, sizeof(*frame));
+
+  frame->library_owns_data = 1;
+
+  if (data_bytes > 0) {
+    frame->data_bytes = data_bytes;
+    frame->data = malloc(data_bytes);
+
+    if (!frame->data) {
+      free(frame);
+      return NULL;
+    }
+  }
+
+  return frame;
+}
+
+/** @brief Free a frame structure
+ * @ingroup frame
+ *
+ * @param frame Frame to destroy
+ */
+void uvc_free_frame(uvc_frame_t *frame) {
+  if (frame->library_owns_data)
+  {
+    if (frame->data_bytes > 0)
+      free(frame->data);
+    if (frame->metadata_bytes > 0)
+      free(frame->metadata);
+  }
+
+  free(frame);
+}
+
+static inline unsigned char sat(int i) {
+  return (unsigned char)( i >= 255 ? 255 : (i < 0 ? 0 : i));
+}
+
+/** @brief Duplicate a frame, preserving color format
+ * @ingroup frame
+ *
+ * @param in Original frame
+ * @param out Duplicate frame
+ */
+uvc_error_t uvc_duplicate_frame(uvc_frame_t *in, uvc_frame_t *out) {
+  if (uvc_ensure_frame_size(out, in->data_bytes) < 0)
+    return UVC_ERROR_NO_MEM;
+
+  out->width = in->width;
+  out->height = in->height;
+  out->frame_format = in->frame_format;
+  out->step = in->step;
+  out->sequence = in->sequence;
+  out->capture_time = in->capture_time;
+  out->capture_time_finished = in->capture_time_finished;
+  out->source = in->source;
+
+  memcpy(out->data, in->data, in->data_bytes);
+
+  if (in->metadata && in->metadata_bytes > 0)
+  {
+      if (out->metadata_bytes < in->metadata_bytes)
+      {
+          out->metadata = realloc(out->metadata, in->metadata_bytes);
+      }
+      out->metadata_bytes = in->metadata_bytes;
+      memcpy(out->metadata, in->metadata, in->metadata_bytes);
+  }
+
+  return UVC_SUCCESS;
+}
+
+#define YUYV2RGB_2(pyuv, prgb) { \
+    float r = 1.402f * ((pyuv)[3]-128); \
+    float g = -0.34414f * ((pyuv)[1]-128) - 0.71414f * ((pyuv)[3]-128); \
+    float b = 1.772f * ((pyuv)[1]-128); \
+    (prgb)[0] = sat(pyuv[0] + r); \
+    (prgb)[1] = sat(pyuv[0] + g); \
+    (prgb)[2] = sat(pyuv[0] + b); \
+    (prgb)[3] = sat(pyuv[2] + r); \
+    (prgb)[4] = sat(pyuv[2] + g); \
+    (prgb)[5] = sat(pyuv[2] + b); \
+    }
+#define IYUYV2RGB_2(pyuv, prgb) { \
+    int r = (22987 * ((pyuv)[3] - 128)) >> 14; \
+    int g = (-5636 * ((pyuv)[1] - 128) - 11698 * ((pyuv)[3] - 128)) >> 14; \
+    int b = (29049 * ((pyuv)[1] - 128)) >> 14; \
+    (prgb)[0] = sat(*(pyuv) + r); \
+    (prgb)[1] = sat(*(pyuv) + g); \
+    (prgb)[2] = sat(*(pyuv) + b); \
+    (prgb)[3] = sat((pyuv)[2] + r); \
+    (prgb)[4] = sat((pyuv)[2] + g); \
+    (prgb)[5] = sat((pyuv)[2] + b); \
+    }
+#define IYUYV2RGB_16(pyuv, prgb) IYUYV2RGB_8(pyuv, prgb); IYUYV2RGB_8(pyuv + 16, prgb + 24);
+#define IYUYV2RGB_8(pyuv, prgb) IYUYV2RGB_4(pyuv, prgb); IYUYV2RGB_4(pyuv + 8, prgb + 12);
+#define IYUYV2RGB_4(pyuv, prgb) IYUYV2RGB_2(pyuv, prgb); IYUYV2RGB_2(pyuv + 4, prgb + 6);
+
+/** @brief Convert a frame from YUYV to RGB
+ * @ingroup frame
+ *
+ * @param in YUYV frame
+ * @param out RGB frame
+ */
+uvc_error_t uvc_yuyv2rgb(uvc_frame_t *in, uvc_frame_t *out) {
+  if (in->frame_format != UVC_FRAME_FORMAT_YUYV)
+    return UVC_ERROR_INVALID_PARAM;
+
+  if (uvc_ensure_frame_size(out, in->width * in->height * 3) < 0)
+    return UVC_ERROR_NO_MEM;
+
+  out->width = in->width;
+  out->height = in->height;
+  out->frame_format = UVC_FRAME_FORMAT_RGB;
+  out->step = in->width * 3;
+  out->sequence = in->sequence;
+  out->capture_time = in->capture_time;
+  out->capture_time_finished = in->capture_time_finished;
+  out->source = in->source;
+
+  uint8_t *pyuv = in->data;
+  uint8_t *prgb = out->data;
+  uint8_t *prgb_end = prgb + out->data_bytes;
+
+  while (prgb < prgb_end) {
+    IYUYV2RGB_8(pyuv, prgb);
+
+    prgb += 3 * 8;
+    pyuv += 2 * 8;
+  }
+
+  return UVC_SUCCESS;
+}
+
+#define IYUYV2BGR_2(pyuv, pbgr) { \
+    int r = (22987 * ((pyuv)[3] - 128)) >> 14; \
+    int g = (-5636 * ((pyuv)[1] - 128) - 11698 * ((pyuv)[3] - 128)) >> 14; \
+    int b = (29049 * ((pyuv)[1] - 128)) >> 14; \
+    (pbgr)[0] = sat(*(pyuv) + b); \
+    (pbgr)[1] = sat(*(pyuv) + g); \
+    (pbgr)[2] = sat(*(pyuv) + r); \
+    (pbgr)[3] = sat((pyuv)[2] + b); \
+    (pbgr)[4] = sat((pyuv)[2] + g); \
+    (pbgr)[5] = sat((pyuv)[2] + r); \
+    }
+#define IYUYV2BGR_16(pyuv, pbgr) IYUYV2BGR_8(pyuv, pbgr); IYUYV2BGR_8(pyuv + 16, pbgr + 24);
+#define IYUYV2BGR_8(pyuv, pbgr) IYUYV2BGR_4(pyuv, pbgr); IYUYV2BGR_4(pyuv + 8, pbgr + 12);
+#define IYUYV2BGR_4(pyuv, pbgr) IYUYV2BGR_2(pyuv, pbgr); IYUYV2BGR_2(pyuv + 4, pbgr + 6);
+
+/** @brief Convert a frame from YUYV to BGR
+ * @ingroup frame
+ *
+ * @param in YUYV frame
+ * @param out BGR frame
+ */
+uvc_error_t uvc_yuyv2bgr(uvc_frame_t *in, uvc_frame_t *out) {
+  if (in->frame_format != UVC_FRAME_FORMAT_YUYV)
+    return UVC_ERROR_INVALID_PARAM;
+
+  if (uvc_ensure_frame_size(out, in->width * in->height * 3) < 0)
+    return UVC_ERROR_NO_MEM;
+
+  out->width = in->width;
+  out->height = in->height;
+  out->frame_format = UVC_FRAME_FORMAT_BGR;
+  out->step = in->width * 3;
+  out->sequence = in->sequence;
+  out->capture_time = in->capture_time;
+  out->capture_time_finished = in->capture_time_finished;
+  out->source = in->source;
+
+  uint8_t *pyuv = in->data;
+  uint8_t *pbgr = out->data;
+  uint8_t *pbgr_end = pbgr + out->data_bytes;
+
+  while (pbgr < pbgr_end) {
+    IYUYV2BGR_8(pyuv, pbgr);
+
+    pbgr += 3 * 8;
+    pyuv += 2 * 8;
+  }
+
+  return UVC_SUCCESS;
+}
+
+#define IYUYV2Y(pyuv, py) { \
+    (py)[0] = (pyuv[0]); \
+    }
+
+/** @brief Convert a frame from YUYV to Y (GRAY8)
+ * @ingroup frame
+ *
+ * @param in YUYV frame
+ * @param out GRAY8 frame
+ */
+uvc_error_t uvc_yuyv2y(uvc_frame_t *in, uvc_frame_t *out) {
+  if (in->frame_format != UVC_FRAME_FORMAT_YUYV)
+    return UVC_ERROR_INVALID_PARAM;
+
+  if (uvc_ensure_frame_size(out, in->width * in->height) < 0)
+    return UVC_ERROR_NO_MEM;
+
+  out->width = in->width;
+  out->height = in->height;
+  out->frame_format = UVC_FRAME_FORMAT_GRAY8;
+  out->step = in->width;
+  out->sequence = in->sequence;
+  out->capture_time = in->capture_time;
+  out->capture_time_finished = in->capture_time_finished;
+  out->source = in->source;
+
+  uint8_t *pyuv = in->data;
+  uint8_t *py = out->data;
+  uint8_t *py_end = py + out->data_bytes;
+
+  while (py < py_end) {
+    IYUYV2Y(pyuv, py);
+
+    py += 1;
+    pyuv += 2;
+  }
+
+  return UVC_SUCCESS;
+}
+
+#define IYUYV2UV(pyuv, puv) { \
+    (puv)[0] = (pyuv[1]); \
+    }
+
+/** @brief Convert a frame from YUYV to UV (GRAY8)
+ * @ingroup frame
+ *
+ * @param in YUYV frame
+ * @param out GRAY8 frame
+ */
+uvc_error_t uvc_yuyv2uv(uvc_frame_t *in, uvc_frame_t *out) {
+  if (in->frame_format != UVC_FRAME_FORMAT_YUYV)
+    return UVC_ERROR_INVALID_PARAM;
+
+  if (uvc_ensure_frame_size(out, in->width * in->height) < 0)
+    return UVC_ERROR_NO_MEM;
+
+  out->width = in->width;
+  out->height = in->height;
+  out->frame_format = UVC_FRAME_FORMAT_GRAY8;
+  out->step = in->width;
+  out->sequence = in->sequence;
+  out->capture_time = in->capture_time;
+  out->capture_time_finished = in->capture_time_finished;
+  out->source = in->source;
+
+  uint8_t *pyuv = in->data;
+  uint8_t *puv = out->data;
+  uint8_t *puv_end = puv + out->data_bytes;
+
+  while (puv < puv_end) {
+    IYUYV2UV(pyuv, puv);
+
+    puv += 1;
+    pyuv += 2;
+  }
+
+  return UVC_SUCCESS;
+}
+
+#define IUYVY2RGB_2(pyuv, prgb) { \
+    int r = (22987 * ((pyuv)[2] - 128)) >> 14; \
+    int g = (-5636 * ((pyuv)[0] - 128) - 11698 * ((pyuv)[2] - 128)) >> 14; \
+    int b = (29049 * ((pyuv)[0] - 128)) >> 14; \
+    (prgb)[0] = sat((pyuv)[1] + r); \
+    (prgb)[1] = sat((pyuv)[1] + g); \
+    (prgb)[2] = sat((pyuv)[1] + b); \
+    (prgb)[3] = sat((pyuv)[3] + r); \
+    (prgb)[4] = sat((pyuv)[3] + g); \
+    (prgb)[5] = sat((pyuv)[3] + b); \
+    }
+#define IUYVY2RGB_16(pyuv, prgb) IUYVY2RGB_8(pyuv, prgb); IUYVY2RGB_8(pyuv + 16, prgb + 24);
+#define IUYVY2RGB_8(pyuv, prgb) IUYVY2RGB_4(pyuv, prgb); IUYVY2RGB_4(pyuv + 8, prgb + 12);
+#define IUYVY2RGB_4(pyuv, prgb) IUYVY2RGB_2(pyuv, prgb); IUYVY2RGB_2(pyuv + 4, prgb + 6);
+
+/** @brief Convert a frame from UYVY to RGB
+ * @ingroup frame
+ * @param ini UYVY frame
+ * @param out RGB frame
+ */
+uvc_error_t uvc_uyvy2rgb(uvc_frame_t *in, uvc_frame_t *out) {
+  if (in->frame_format != UVC_FRAME_FORMAT_UYVY)
+    return UVC_ERROR_INVALID_PARAM;
+
+  if (uvc_ensure_frame_size(out, in->width * in->height * 3) < 0)
+    return UVC_ERROR_NO_MEM;
+
+  out->width = in->width;
+  out->height = in->height;
+  out->frame_format = UVC_FRAME_FORMAT_RGB;
+  out->step = in->width *3;
+  out->sequence = in->sequence;
+  out->capture_time = in->capture_time;
+  out->capture_time_finished = in->capture_time_finished;
+  out->source = in->source;
+
+  uint8_t *pyuv = in->data;
+  uint8_t *prgb = out->data;
+  uint8_t *prgb_end = prgb + out->data_bytes;
+
+  while (prgb < prgb_end) {
+    IUYVY2RGB_8(pyuv, prgb);
+
+    prgb += 3 * 8;
+    pyuv += 2 * 8;
+  }
+
+  return UVC_SUCCESS;
+}
+
+#define IUYVY2BGR_2(pyuv, pbgr) { \
+    int r = (22987 * ((pyuv)[2] - 128)) >> 14; \
+    int g = (-5636 * ((pyuv)[0] - 128) - 11698 * ((pyuv)[2] - 128)) >> 14; \
+    int b = (29049 * ((pyuv)[0] - 128)) >> 14; \
+    (pbgr)[0] = sat((pyuv)[1] + b); \
+    (pbgr)[1] = sat((pyuv)[1] + g); \
+    (pbgr)[2] = sat((pyuv)[1] + r); \
+    (pbgr)[3] = sat((pyuv)[3] + b); \
+    (pbgr)[4] = sat((pyuv)[3] + g); \
+    (pbgr)[5] = sat((pyuv)[3] + r); \
+    }
+#define IUYVY2BGR_16(pyuv, pbgr) IUYVY2BGR_8(pyuv, pbgr); IUYVY2BGR_8(pyuv + 16, pbgr + 24);
+#define IUYVY2BGR_8(pyuv, pbgr) IUYVY2BGR_4(pyuv, pbgr); IUYVY2BGR_4(pyuv + 8, pbgr + 12);
+#define IUYVY2BGR_4(pyuv, pbgr) IUYVY2BGR_2(pyuv, pbgr); IUYVY2BGR_2(pyuv + 4, pbgr + 6);
+
+/** @brief Convert a frame from UYVY to BGR
+ * @ingroup frame
+ * @param ini UYVY frame
+ * @param out BGR frame
+ */
+uvc_error_t uvc_uyvy2bgr(uvc_frame_t *in, uvc_frame_t *out) {
+  if (in->frame_format != UVC_FRAME_FORMAT_UYVY)
+    return UVC_ERROR_INVALID_PARAM;
+
+  if (uvc_ensure_frame_size(out, in->width * in->height * 3) < 0)
+    return UVC_ERROR_NO_MEM;
+
+  out->width = in->width;
+  out->height = in->height;
+  out->frame_format = UVC_FRAME_FORMAT_BGR;
+  out->step = in->width *3;
+  out->sequence = in->sequence;
+  out->capture_time = in->capture_time;
+  out->capture_time_finished = in->capture_time_finished;
+  out->source = in->source;
+
+  uint8_t *pyuv = in->data;
+  uint8_t *pbgr = out->data;
+  uint8_t *pbgr_end = pbgr + out->data_bytes;
+
+  while (pbgr < pbgr_end) {
+    IUYVY2BGR_8(pyuv, pbgr);
+
+    pbgr += 3 * 8;
+    pyuv += 2 * 8;
+  }
+
+  return UVC_SUCCESS;
+}
+
+/** @brief Convert a frame to RGB
+ * @ingroup frame
+ *
+ * @param in non-RGB frame
+ * @param out RGB frame
+ */
+uvc_error_t uvc_any2rgb(uvc_frame_t *in, uvc_frame_t *out) {
+  switch (in->frame_format) {
+#ifdef LIBUVC_HAS_JPEG
+    case UVC_FRAME_FORMAT_MJPEG:
+      return uvc_mjpeg2rgb(in, out);
+#endif
+    case UVC_FRAME_FORMAT_YUYV:
+      return uvc_yuyv2rgb(in, out);
+    case UVC_FRAME_FORMAT_UYVY:
+      return uvc_uyvy2rgb(in, out);
+    case UVC_FRAME_FORMAT_RGB:
+      return uvc_duplicate_frame(in, out);
+    default:
+      return UVC_ERROR_NOT_SUPPORTED;
+  }
+}
+
+/** @brief Convert a frame to BGR
+ * @ingroup frame
+ *
+ * @param in non-BGR frame
+ * @param out BGR frame
+ */
+uvc_error_t uvc_any2bgr(uvc_frame_t *in, uvc_frame_t *out) {
+  switch (in->frame_format) {
+    case UVC_FRAME_FORMAT_YUYV:
+      return uvc_yuyv2bgr(in, out);
+    case UVC_FRAME_FORMAT_UYVY:
+      return uvc_uyvy2bgr(in, out);
+    case UVC_FRAME_FORMAT_BGR:
+      return uvc_duplicate_frame(in, out);
+    default:
+      return UVC_ERROR_NOT_SUPPORTED;
+  }
+}

collector/core/gripper/camera_service_src/third_party/libuvc/src/init.c

@@ -0,0 +1,163 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+/**
+\mainpage libuvc: a cross-platform library for USB video devices
+
+\b libuvc is a library that supports enumeration, control and streaming
+for USB Video Class (UVC) devices, such as consumer webcams.
+
+\section features Features
+\li UVC device \ref device "discovery and management" API
+\li \ref streaming "Video streaming" (device to host) with asynchronous/callback and synchronous/polling modes
+\li Read/write access to standard \ref ctrl "device settings"
+\li \ref frame "Conversion" between various formats: RGB, YUV, JPEG, etc.
+\li Tested on Mac and Linux, portable to Windows and some BSDs
+
+\section roadmap Roadmap
+\li Bulk-mode image capture
+\li One-shot image capture
+\li Improved support for standard settings
+\li Support for "extended" (vendor-defined) settings
+
+\section misc Misc.
+\p The source code can be found at https://github.com/libuvc/libuvc/. To build
+the library, install <a href="https://libusb.info/">libusb</a> 1.0+ and run:
+
+\code
+$ git clone https://github.com/libuvc/libuvc.git
+$ cd libuvc
+$ mkdir build
+$ cd build
+$ cmake -DCMAKE_BUILD_TYPE=Release ..
+$ make && make install
+\endcode
+
+\section Example
+In this example, libuvc is used to acquire images in a 30 fps, 640x480
+YUV stream from a UVC device such as a standard webcam.
+
+\include example.c
+
+*/
+
+/**
+ * @defgroup init Library initialization/deinitialization
+ * @brief Setup routines used to construct UVC access contexts
+ */
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+
+/** @internal
+ * @brief Event handler thread
+ * There's one of these per UVC context.
+ * @todo We shouldn't run this if we don't own the USB context
+ */
+void *_uvc_handle_events(void *arg) {
+  uvc_context_t *ctx = (uvc_context_t *) arg;
+
+  while (!ctx->kill_handler_thread)
+    libusb_handle_events_completed(ctx->usb_ctx, &ctx->kill_handler_thread);
+  return NULL;
+}
+
+/** @brief Initializes the UVC context
+ * @ingroup init
+ *
+ * @note If you provide your own USB context, you must handle
+ * libusb event processing using a function such as libusb_handle_events.
+ *
+ * @param[out] pctx The location where the context reference should be stored.
+ * @param[in]  usb_ctx Optional USB context to use
+ * @return Error opening context or UVC_SUCCESS
+ */
+uvc_error_t uvc_init(uvc_context_t **pctx, struct libusb_context *usb_ctx) {
+  uvc_error_t ret = UVC_SUCCESS;
+  uvc_context_t *ctx = calloc(1, sizeof(*ctx));
+
+  if (usb_ctx == NULL) {
+    ret = libusb_init(&ctx->usb_ctx);
+    ctx->own_usb_ctx = 1;
+    if (ret != UVC_SUCCESS) {
+      free(ctx);
+      ctx = NULL;
+    }
+  } else {
+    ctx->own_usb_ctx = 0;
+    ctx->usb_ctx = usb_ctx;
+  }
+
+  if (ctx != NULL)
+    *pctx = ctx;
+
+  return ret;
+}
+
+/**
+ * @brief Closes the UVC context, shutting down any active cameras.
+ * @ingroup init
+ *
+ * @note This function invalides any existing references to the context's
+ * cameras.
+ *
+ * If no USB context was provided to #uvc_init, the UVC-specific USB
+ * context will be destroyed.
+ *
+ * @param ctx UVC context to shut down
+ */
+void uvc_exit(uvc_context_t *ctx) {
+  uvc_device_handle_t *devh;
+
+  DL_FOREACH(ctx->open_devices, devh) {
+    uvc_close(devh);
+  }
+
+  if (ctx->own_usb_ctx)
+    libusb_exit(ctx->usb_ctx);
+
+  free(ctx);
+}
+
+/**
+ * @internal
+ * @brief Spawns a handler thread for the context
+ * @ingroup init
+ *
+ * This should be called at the end of a successful uvc_open if no devices
+ * are already open (and being handled).
+ */
+void uvc_start_handler_thread(uvc_context_t *ctx) {
+  if (ctx->own_usb_ctx)
+    pthread_create(&ctx->handler_thread, NULL, _uvc_handle_events, (void*) ctx);
+}
+

collector/core/gripper/camera_service_src/third_party/libuvc/src/misc.c

@@ -0,0 +1,58 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+#include <string.h>
+#include <stdlib.h>
+
+#if __APPLE__
+char *strndup(const char *s, size_t n) {
+  size_t src_n = 0;
+  const char *sp = s;
+  char *d;
+
+  while (*sp++)
+    src_n++;
+
+  if (src_n < n)
+    n = src_n;
+
+  d = malloc(n + 1);
+
+  memcpy(d, s, n);
+  
+  d[n] = '\0';
+
+  return d;
+}
+#endif
+

collector/core/gripper/camera_service_src/third_party/libuvc/src/stream.c

@@ -0,0 +1,1752 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+/**
+ * @defgroup streaming Streaming control functions
+ * @brief Tools for creating, managing and consuming video streams
+ */
+
+#include "libuvc/libuvc.h"
+#include "libuvc/libuvc_internal.h"
+#include "errno.h"
+
+#ifdef _MSC_VER
+
+#define DELTA_EPOCH_IN_MICROSECS  116444736000000000Ui64
+
+// gettimeofday - get time of day for Windows;
+// A gettimeofday implementation for Microsoft Windows;
+// Public domain code, author "ponnada";
+int gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+    FILETIME ft;
+    unsigned __int64 tmpres = 0;
+    static int tzflag = 0;
+    if (NULL != tv)
+    {
+        GetSystemTimeAsFileTime(&ft);
+        tmpres |= ft.dwHighDateTime;
+        tmpres <<= 32;
+        tmpres |= ft.dwLowDateTime;
+        tmpres /= 10;
+        tmpres -= DELTA_EPOCH_IN_MICROSECS;
+        tv->tv_sec = (long)(tmpres / 1000000UL);
+        tv->tv_usec = (long)(tmpres % 1000000UL);
+    }
+    return 0;
+}
+#endif // _MSC_VER
+uvc_frame_desc_t *uvc_find_frame_desc_stream(uvc_stream_handle_t *strmh,
+    uint16_t format_id, uint16_t frame_id);
+uvc_frame_desc_t *uvc_find_frame_desc(uvc_device_handle_t *devh,
+    uint16_t format_id, uint16_t frame_id);
+void *_uvc_user_caller(void *arg);
+void _uvc_populate_frame(uvc_stream_handle_t *strmh);
+
+static uvc_streaming_interface_t *_uvc_get_stream_if(uvc_device_handle_t *devh, int interface_idx);
+static uvc_stream_handle_t *_uvc_get_stream_by_interface(uvc_device_handle_t *devh, int interface_idx);
+static enum uvc_frame_format uvc_frame_format_for_guid(uint8_t guid[16]);
+
+/*
+ * The project cameras advertise a larger UVC payload than they need for the
+ * production MJPEG modes.  The workaround must update the UVC COMMIT control
+ * before the host selects an altsetting; changing only libusb's transfer
+ * geometry leaves the camera's negotiated payload at its oversized value.
+ * This is deliberately an exact VID/PID + format + size + frame-rate match.
+ */
+struct ksq_altsetting_quirk {
+  uint16_t vid;
+  uint16_t pid;
+  uint8_t streaming_interface;
+  uint8_t forced_altsetting;
+  uint16_t payload;
+  uint16_t width;
+  uint16_t height;
+};
+
+static const struct ksq_altsetting_quirk ksq_altsetting_quirks[] = {
+  /* 2026-08-28 alt-3 verification: Sightac alt4/1600 -> alt3/800 (5-cam USB
+   * budget). Revert this line to {0x0c45, 0x636f, 1, 4, 1600, 640, 480} to
+   * restore the production 2-cam-per-set mode. */
+  {0x0c45, 0x636f, 1, 3, 800, 640, 480},
+  /* 2026-09-15 DECXIN default is alt6/944, the largest single-transaction
+   * setting. It is the safe fallback, not the preferred mode: it only fits
+   * 8 x 32 x 944 = 241664 B per frame against a measured worst case of
+   * 234148 B, so a busier scene truncates frames, while alt7/1280 fits
+   * 327680 B. The service therefore pins alt7/1280 per device through
+   * uvc_set_altsetting_override() on controllers that can carry it, and
+   * drops back to this entry when it cannot. alt7 is a high-bandwidth
+   * isochronous setting (2 transactions per microframe) that stalls the AMD
+   * 1022:15b7 controller within 45..130 s, every time. */
+  {0x1bcf, 0x2d4f, 1, 6, 944, 1280, 960},
+};
+
+/* The altsetting/payload pair a stream should be opened with, either from the
+ * caller's per-device override or, failing that, from the table above. */
+struct ksq_altsetting_choice {
+  uint16_t vid;
+  uint16_t pid;
+  uint8_t altsetting;
+  uint16_t payload;
+  int from_override;
+};
+
+/* Returns 1 and fills @p out when a setting was resolved, 0 when the stream
+ * should be opened with libuvc's own altsetting search. */
+static int _ksq_resolve_altsetting_for_ctrl(
+    uvc_device_handle_t *devh, const uvc_stream_ctrl_t *ctrl,
+    enum uvc_frame_format frame_format, uvc_frame_desc_t *frame_desc,
+    struct ksq_altsetting_choice *out) {
+  struct libusb_device_descriptor descriptor;
+  int have_descriptor;
+  size_t index;
+
+  if (devh == NULL || ctrl == NULL || frame_desc == NULL || out == NULL) {
+    return 0;
+  }
+
+  /* An explicit override wins over the table: the table is a per-model
+   * default, the override is a per-machine measurement of what this host
+   * controller can carry. It is deliberately not gated on format/size/
+   * interval -- the caller already validated the mode it asked for, and the
+   * endpoint check in uvc_stream_start() still rejects an altsetting that the
+   * streaming interface does not actually have. */
+  if (devh->altsetting_override_valid) {
+    have_descriptor =
+        libusb_get_device_descriptor(devh->dev->usb_dev, &descriptor) == 0;
+    out->vid = have_descriptor ? descriptor.idVendor : 0;
+    out->pid = have_descriptor ? descriptor.idProduct : 0;
+    out->altsetting = devh->altsetting_override_altsetting;
+    out->payload = devh->altsetting_override_payload;
+    out->from_override = 1;
+    return 1;
+  }
+
+  if (frame_format != UVC_FRAME_FORMAT_MJPEG ||
+      ctrl->dwFrameInterval < 330000 || ctrl->dwFrameInterval > 340000 ||
+      frame_desc->parent == NULL || frame_desc->parent->parent == NULL ||
+      libusb_get_device_descriptor(devh->dev->usb_dev, &descriptor) != 0) {
+    return 0;
+  }
+
+  for (index = 0;
+       index < sizeof(ksq_altsetting_quirks) /
+                   sizeof(ksq_altsetting_quirks[0]);
+       ++index) {
+    const struct ksq_altsetting_quirk *quirk = &ksq_altsetting_quirks[index];
+    if (descriptor.idVendor == quirk->vid &&
+        descriptor.idProduct == quirk->pid &&
+        frame_desc->wWidth == quirk->width &&
+        frame_desc->wHeight == quirk->height &&
+        frame_desc->parent->parent->bInterfaceNumber ==
+            quirk->streaming_interface) {
+      out->vid = quirk->vid;
+      out->pid = quirk->pid;
+      out->altsetting = quirk->forced_altsetting;
+      out->payload = quirk->payload;
+      out->from_override = 0;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+struct format_table_entry {
+  enum uvc_frame_format format;
+  uint8_t abstract_fmt;
+  uint8_t guid[16];
+  int children_count;
+  enum uvc_frame_format *children;
+};
+
+struct format_table_entry *_get_format_entry(enum uvc_frame_format format) {
+  #define ABS_FMT(_fmt, _num, ...) \
+    case _fmt: { \
+    static enum uvc_frame_format _fmt##_children[] = __VA_ARGS__; \
+    static struct format_table_entry _fmt##_entry = { \
+      _fmt, 0, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, _num, _fmt##_children }; \
+    return &_fmt##_entry; }
+
+  #define FMT(_fmt, ...) \
+    case _fmt: { \
+    static struct format_table_entry _fmt##_entry = { \
+      _fmt, 0, __VA_ARGS__, 0, NULL }; \
+    return &_fmt##_entry; }
+
+  switch(format) {
+    /* Define new formats here */
+    ABS_FMT(UVC_FRAME_FORMAT_ANY, 2,
+      {UVC_FRAME_FORMAT_UNCOMPRESSED, UVC_FRAME_FORMAT_COMPRESSED})
+
+    ABS_FMT(UVC_FRAME_FORMAT_UNCOMPRESSED, 8,
+      {UVC_FRAME_FORMAT_YUYV, UVC_FRAME_FORMAT_UYVY, UVC_FRAME_FORMAT_GRAY8,
+       UVC_FRAME_FORMAT_GRAY16, UVC_FRAME_FORMAT_NV12, UVC_FRAME_FORMAT_P010,
+       UVC_FRAME_FORMAT_BGR, UVC_FRAME_FORMAT_RGB})
+    FMT(UVC_FRAME_FORMAT_YUYV,
+      {'Y',  'U',  'Y',  '2', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    FMT(UVC_FRAME_FORMAT_UYVY,
+      {'U',  'Y',  'V',  'Y', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    FMT(UVC_FRAME_FORMAT_GRAY8,
+      {'Y',  '8',  '0',  '0', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    FMT(UVC_FRAME_FORMAT_GRAY16,
+      {'Y',  '1',  '6',  ' ', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    FMT(UVC_FRAME_FORMAT_NV12,
+      {'N',  'V',  '1',  '2', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    FMT(UVC_FRAME_FORMAT_P010,
+      {'P',  '0',  '1',  '0', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    FMT(UVC_FRAME_FORMAT_BGR,
+      {0x7d, 0xeb, 0x36, 0xe4, 0x4f, 0x52, 0xce, 0x11, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70})
+    FMT(UVC_FRAME_FORMAT_RGB,
+        {0x7e, 0xeb, 0x36, 0xe4, 0x4f, 0x52, 0xce, 0x11, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70})
+    FMT(UVC_FRAME_FORMAT_BY8,
+      {'B',  'Y',  '8',  ' ', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    FMT(UVC_FRAME_FORMAT_BA81,
+      {'B',  'A',  '8',  '1', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    FMT(UVC_FRAME_FORMAT_SGRBG8,
+      {'G',  'R',  'B',  'G', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    FMT(UVC_FRAME_FORMAT_SGBRG8,
+      {'G',  'B',  'R',  'G', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    FMT(UVC_FRAME_FORMAT_SRGGB8,
+      {'R',  'G',  'G',  'B', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    FMT(UVC_FRAME_FORMAT_SBGGR8,
+      {'B',  'G',  'G',  'R', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+    ABS_FMT(UVC_FRAME_FORMAT_COMPRESSED, 2,
+      {UVC_FRAME_FORMAT_MJPEG, UVC_FRAME_FORMAT_H264})
+    FMT(UVC_FRAME_FORMAT_MJPEG,
+      {'M',  'J',  'P',  'G'})
+    FMT(UVC_FRAME_FORMAT_H264,
+      {'H',  '2',  '6',  '4', 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71})
+
+    default:
+      return NULL;
+  }
+
+  #undef ABS_FMT
+  #undef FMT
+}
+
+static uint8_t _uvc_frame_format_matches_guid(enum uvc_frame_format fmt, uint8_t guid[16]) {
+  struct format_table_entry *format;
+  int child_idx;
+
+  format = _get_format_entry(fmt);
+  if (!format)
+    return 0;
+
+  if (!format->abstract_fmt && !memcmp(guid, format->guid, 16))
+    return 1;
+
+  for (child_idx = 0; child_idx < format->children_count; child_idx++) {
+    if (_uvc_frame_format_matches_guid(format->children[child_idx], guid))
+      return 1;
+  }
+
+  return 0;
+}
+
+static enum uvc_frame_format uvc_frame_format_for_guid(uint8_t guid[16]) {
+  struct format_table_entry *format;
+  enum uvc_frame_format fmt;
+
+  for (fmt = 0; fmt < UVC_FRAME_FORMAT_COUNT; ++fmt) {
+    format = _get_format_entry(fmt);
+    if (!format || format->abstract_fmt)
+      continue;
+    if (!memcmp(format->guid, guid, 16))
+      return format->format;
+  }
+
+  return UVC_FRAME_FORMAT_UNKNOWN;
+}
+
+/** @internal
+ * Run a streaming control query
+ * @param[in] devh UVC device
+ * @param[in,out] ctrl Control block
+ * @param[in] probe Whether this is a probe query or a commit query
+ * @param[in] req Query type
+ */
+uvc_error_t uvc_query_stream_ctrl(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    uint8_t probe,
+    enum uvc_req_code req) {
+  uint8_t buf[34];
+  size_t len;
+  uvc_error_t err;
+
+  memset(buf, 0, sizeof(buf));
+
+  if (devh->info->ctrl_if.bcdUVC >= 0x0110)
+    len = 34;
+  else
+    len = 26;
+
+  /* prepare for a SET transfer */
+  if (req == UVC_SET_CUR) {
+    SHORT_TO_SW(ctrl->bmHint, buf);
+    buf[2] = ctrl->bFormatIndex;
+    buf[3] = ctrl->bFrameIndex;
+    INT_TO_DW(ctrl->dwFrameInterval, buf + 4);
+    SHORT_TO_SW(ctrl->wKeyFrameRate, buf + 8);
+    SHORT_TO_SW(ctrl->wPFrameRate, buf + 10);
+    SHORT_TO_SW(ctrl->wCompQuality, buf + 12);
+    SHORT_TO_SW(ctrl->wCompWindowSize, buf + 14);
+    SHORT_TO_SW(ctrl->wDelay, buf + 16);
+    INT_TO_DW(ctrl->dwMaxVideoFrameSize, buf + 18);
+    INT_TO_DW(ctrl->dwMaxPayloadTransferSize, buf + 22);
+
+    if (len == 34) {
+      INT_TO_DW ( ctrl->dwClockFrequency, buf + 26 );
+      buf[30] = ctrl->bmFramingInfo;
+      buf[31] = ctrl->bPreferredVersion;
+      buf[32] = ctrl->bMinVersion;
+      buf[33] = ctrl->bMaxVersion;
+      /** @todo support UVC 1.1 */
+    }
+  }
+
+  /* do the transfer */
+  err = libusb_control_transfer(
+      devh->usb_devh,
+      req == UVC_SET_CUR ? 0x21 : 0xA1,
+      req,
+      probe ? (UVC_VS_PROBE_CONTROL << 8) : (UVC_VS_COMMIT_CONTROL << 8),
+      ctrl->bInterfaceNumber,
+      buf, len, 0
+  );
+
+  if (err <= 0) {
+    return err;
+  }
+
+  /* now decode following a GET transfer */
+  if (req != UVC_SET_CUR) {
+    ctrl->bmHint = SW_TO_SHORT(buf);
+    ctrl->bFormatIndex = buf[2];
+    ctrl->bFrameIndex = buf[3];
+    ctrl->dwFrameInterval = DW_TO_INT(buf + 4);
+    ctrl->wKeyFrameRate = SW_TO_SHORT(buf + 8);
+    ctrl->wPFrameRate = SW_TO_SHORT(buf + 10);
+    ctrl->wCompQuality = SW_TO_SHORT(buf + 12);
+    ctrl->wCompWindowSize = SW_TO_SHORT(buf + 14);
+    ctrl->wDelay = SW_TO_SHORT(buf + 16);
+    ctrl->dwMaxVideoFrameSize = DW_TO_INT(buf + 18);
+    ctrl->dwMaxPayloadTransferSize = DW_TO_INT(buf + 22);
+
+    if (len == 34) {
+      ctrl->dwClockFrequency = DW_TO_INT ( buf + 26 );
+      ctrl->bmFramingInfo = buf[30];
+      ctrl->bPreferredVersion = buf[31];
+      ctrl->bMinVersion = buf[32];
+      ctrl->bMaxVersion = buf[33];
+      /** @todo support UVC 1.1 */
+    }
+    else
+      ctrl->dwClockFrequency = devh->info->ctrl_if.dwClockFrequency;
+
+    /* fix up block for cameras that fail to set dwMax* */
+    if (ctrl->dwMaxVideoFrameSize == 0) {
+      uvc_frame_desc_t *frame = uvc_find_frame_desc(devh, ctrl->bFormatIndex, ctrl->bFrameIndex);
+
+      if (frame) {
+        ctrl->dwMaxVideoFrameSize = frame->dwMaxVideoFrameBufferSize;
+      }
+    }
+  }
+
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * Run a streaming control query
+ * @param[in] devh UVC device
+ * @param[in,out] ctrl Control block
+ * @param[in] probe Whether this is a probe query or a commit query
+ * @param[in] req Query type
+ */
+uvc_error_t uvc_query_still_ctrl(
+  uvc_device_handle_t *devh,
+  uvc_still_ctrl_t *still_ctrl,
+  uint8_t probe,
+  enum uvc_req_code req) {
+
+  uint8_t buf[11];
+  const size_t len = 11;
+  uvc_error_t err;
+
+  memset(buf, 0, sizeof(buf));
+
+  if (req == UVC_SET_CUR) {
+    /* prepare for a SET transfer */
+    buf[0] = still_ctrl->bFormatIndex;
+    buf[1] = still_ctrl->bFrameIndex;
+    buf[2] = still_ctrl->bCompressionIndex;
+    INT_TO_DW(still_ctrl->dwMaxVideoFrameSize, buf + 3);
+    INT_TO_DW(still_ctrl->dwMaxPayloadTransferSize, buf + 7);
+  }
+
+  /* do the transfer */
+  err = libusb_control_transfer(
+      devh->usb_devh,
+      req == UVC_SET_CUR ? 0x21 : 0xA1,
+      req,
+      probe ? (UVC_VS_STILL_PROBE_CONTROL << 8) : (UVC_VS_STILL_COMMIT_CONTROL << 8),
+      still_ctrl->bInterfaceNumber,
+      buf, len, 0
+  );
+
+  if (err <= 0) {
+    return err;
+  }
+
+  /* now decode following a GET transfer */
+  if (req != UVC_SET_CUR) {
+    still_ctrl->bFormatIndex = buf[0];
+    still_ctrl->bFrameIndex = buf[1];
+    still_ctrl->bCompressionIndex = buf[2];
+    still_ctrl->dwMaxVideoFrameSize = DW_TO_INT(buf + 3);
+    still_ctrl->dwMaxPayloadTransferSize = DW_TO_INT(buf + 7);
+  }
+
+  return UVC_SUCCESS;
+}
+
+/** Initiate a method 2 (in stream) still capture
+ * @ingroup streaming
+ *
+ * @param[in] devh Device handle
+ * @param[in] still_ctrl Still capture control block
+ */
+uvc_error_t uvc_trigger_still(
+    uvc_device_handle_t *devh,
+    uvc_still_ctrl_t *still_ctrl) {
+  uvc_stream_handle_t* stream;
+  uvc_streaming_interface_t* stream_if;
+  uint8_t buf;
+  uvc_error_t err;
+
+  /* Stream must be running for method 2 to work */
+  stream = _uvc_get_stream_by_interface(devh, still_ctrl->bInterfaceNumber);
+  if (!stream || !stream->running)
+    return UVC_ERROR_NOT_SUPPORTED;
+
+  /* Only method 2 is supported */
+  stream_if = _uvc_get_stream_if(devh, still_ctrl->bInterfaceNumber);
+  if(!stream_if || stream_if->bStillCaptureMethod != 2)
+      return UVC_ERROR_NOT_SUPPORTED;
+
+  /* prepare for a SET transfer */
+  buf = 1;
+
+  /* do the transfer */
+  err = libusb_control_transfer(
+      devh->usb_devh,
+      0x21, //type set
+      UVC_SET_CUR,
+      (UVC_VS_STILL_IMAGE_TRIGGER_CONTROL << 8),
+      still_ctrl->bInterfaceNumber,
+      &buf, 1, 0);
+
+  if (err <= 0) {
+    return err;
+  }
+
+  return UVC_SUCCESS;
+}
+
+/** @brief Reconfigure stream with a new stream format.
+ * @ingroup streaming
+ *
+ * This may be executed whether or not the stream is running.
+ *
+ * @param[in] strmh Stream handle
+ * @param[in] ctrl Control block, processed using {uvc_probe_stream_ctrl} or
+ *             {uvc_get_stream_ctrl_format_size}
+ */
+uvc_error_t uvc_stream_ctrl(uvc_stream_handle_t *strmh, uvc_stream_ctrl_t *ctrl) {
+  uvc_error_t ret;
+  uvc_frame_desc_t *frame_desc;
+  enum uvc_frame_format frame_format = UVC_FRAME_FORMAT_UNKNOWN;
+  struct ksq_altsetting_choice choice;
+
+  if (strmh->stream_if->bInterfaceNumber != ctrl->bInterfaceNumber)
+    return UVC_ERROR_INVALID_PARAM;
+
+  /* @todo Allow the stream to be modified without restarting the stream */
+  if (strmh->running)
+    return UVC_ERROR_BUSY;
+
+  /*
+   * Apply the device-specific limit before COMMIT_CONTROL is sent.  The
+   * later altsetting override uses the same value, so the camera's negotiated
+   * payload and libusb's ISO packet geometry remain consistent.
+   */
+  frame_desc = uvc_find_frame_desc_stream(strmh, ctrl->bFormatIndex,
+                                          ctrl->bFrameIndex);
+  if (frame_desc != NULL && frame_desc->parent != NULL) {
+    frame_format = uvc_frame_format_for_guid(frame_desc->parent->guidFormat);
+  }
+  if (_ksq_resolve_altsetting_for_ctrl(strmh->devh, ctrl, frame_format,
+                                       frame_desc, &choice) &&
+      ctrl->dwMaxPayloadTransferSize > choice.payload) {
+    fprintf(stderr,
+            "[LIBUVC-QUIRK] COMMIT payload %u -> %u for VID:PID %04x:%04x%s\n",
+            ctrl->dwMaxPayloadTransferSize, choice.payload,
+            choice.vid, choice.pid,
+            choice.from_override ? " (altsetting override)" : "");
+    ctrl->dwMaxPayloadTransferSize = choice.payload;
+  }
+
+  ret = uvc_query_stream_ctrl(strmh->devh, ctrl, 0, UVC_SET_CUR);
+  if (ret != UVC_SUCCESS)
+    return ret;
+
+  strmh->cur_ctrl = *ctrl;
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * @brief Find the descriptor for a specific frame configuration
+ * @param stream_if Stream interface
+ * @param format_id Index of format class descriptor
+ * @param frame_id Index of frame descriptor
+ */
+static uvc_frame_desc_t *_uvc_find_frame_desc_stream_if(uvc_streaming_interface_t *stream_if,
+    uint16_t format_id, uint16_t frame_id) {
+ 
+  uvc_format_desc_t *format = NULL;
+  uvc_frame_desc_t *frame = NULL;
+
+  DL_FOREACH(stream_if->format_descs, format) {
+    if (format->bFormatIndex == format_id) {
+      DL_FOREACH(format->frame_descs, frame) {
+        if (frame->bFrameIndex == frame_id)
+          return frame;
+      }
+    }
+  }
+
+  return NULL;
+}
+
+uvc_frame_desc_t *uvc_find_frame_desc_stream(uvc_stream_handle_t *strmh,
+    uint16_t format_id, uint16_t frame_id) {
+  return _uvc_find_frame_desc_stream_if(strmh->stream_if, format_id, frame_id);
+}
+
+/** @internal
+ * @brief Find the descriptor for a specific frame configuration
+ * @param devh UVC device
+ * @param format_id Index of format class descriptor
+ * @param frame_id Index of frame descriptor
+ */
+uvc_frame_desc_t *uvc_find_frame_desc(uvc_device_handle_t *devh,
+    uint16_t format_id, uint16_t frame_id) {
+ 
+  uvc_streaming_interface_t *stream_if;
+  uvc_frame_desc_t *frame;
+
+  DL_FOREACH(devh->info->stream_ifs, stream_if) {
+    frame = _uvc_find_frame_desc_stream_if(stream_if, format_id, frame_id);
+    if (frame)
+      return frame;
+  }
+
+  return NULL;
+}
+
+/** Get a negotiated streaming control block for some common parameters.
+ * @ingroup streaming
+ *
+ * @param[in] devh Device handle
+ * @param[in,out] ctrl Control block
+ * @param[in] format_class Type of streaming format
+ * @param[in] width Desired frame width
+ * @param[in] height Desired frame height
+ * @param[in] fps Frame rate, frames per second
+ */
+uvc_error_t uvc_get_stream_ctrl_format_size(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    enum uvc_frame_format cf,
+    int width, int height,
+    int fps) {
+  uvc_streaming_interface_t *stream_if;
+
+  /* find a matching frame descriptor and interval */
+  DL_FOREACH(devh->info->stream_ifs, stream_if) {
+    uvc_format_desc_t *format;
+
+    DL_FOREACH(stream_if->format_descs, format) {
+      uvc_frame_desc_t *frame;
+
+      if (!_uvc_frame_format_matches_guid(cf, format->guidFormat))
+        continue;
+
+      DL_FOREACH(format->frame_descs, frame) {
+        if (frame->wWidth != width || frame->wHeight != height)
+          continue;
+
+        uint32_t *interval;
+
+        ctrl->bInterfaceNumber = stream_if->bInterfaceNumber;
+        UVC_DEBUG("claiming streaming interface %d", stream_if->bInterfaceNumber );
+        uvc_claim_if(devh, ctrl->bInterfaceNumber);
+        /* get the max values */
+        uvc_query_stream_ctrl( devh, ctrl, 1, UVC_GET_MAX);
+
+        if (frame->intervals) {
+          for (interval = frame->intervals; *interval; ++interval) {
+            // allow a fps rate of zero to mean "accept first rate available"
+            if (10000000 / *interval == (unsigned int) fps || fps == 0) {
+
+              ctrl->bmHint = (1 << 0); /* don't negotiate interval */
+              ctrl->bFormatIndex = format->bFormatIndex;
+              ctrl->bFrameIndex = frame->bFrameIndex;
+              ctrl->dwFrameInterval = *interval;
+
+              goto found;
+            }
+          }
+        } else {
+          uint32_t interval_100ns = 10000000 / fps;
+          uint32_t interval_offset = interval_100ns - frame->dwMinFrameInterval;
+
+          if (interval_100ns >= frame->dwMinFrameInterval
+              && interval_100ns <= frame->dwMaxFrameInterval
+              && !(interval_offset
+                   && (interval_offset % frame->dwFrameIntervalStep))) {
+
+            ctrl->bmHint = (1 << 0);
+            ctrl->bFormatIndex = format->bFormatIndex;
+            ctrl->bFrameIndex = frame->bFrameIndex;
+            ctrl->dwFrameInterval = interval_100ns;
+
+            goto found;
+          }
+        }
+      }
+    }
+  }
+
+  return UVC_ERROR_INVALID_MODE;
+
+found:
+  return uvc_probe_stream_ctrl(devh, ctrl);
+}
+
+/** Get a negotiated still control block for some common parameters.
+ * @ingroup streaming
+ *
+ * @param[in] devh Device handle
+ * @param[in] ctrl Control block
+ * @param[in, out] still_ctrl Still capture control block
+ * @param[in] width Desired frame width
+ * @param[in] height Desired frame height
+ */
+uvc_error_t uvc_get_still_ctrl_format_size(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    uvc_still_ctrl_t *still_ctrl,
+    int width, int height) {
+  uvc_streaming_interface_t *stream_if;
+  uvc_still_frame_desc_t *still;
+  uvc_format_desc_t *format;
+  uvc_still_frame_res_t *sizePattern;
+
+  stream_if = _uvc_get_stream_if(devh, ctrl->bInterfaceNumber);
+
+  /* Only method 2 is supported */
+  if(!stream_if || stream_if->bStillCaptureMethod != 2)
+    return UVC_ERROR_NOT_SUPPORTED;
+
+  DL_FOREACH(stream_if->format_descs, format) {
+
+    if (ctrl->bFormatIndex != format->bFormatIndex)
+      continue;
+
+    /* get the max values */
+    uvc_query_still_ctrl(devh, still_ctrl, 1, UVC_GET_MAX);
+
+    //look for still format
+    DL_FOREACH(format->still_frame_desc, still) {
+      DL_FOREACH(still->imageSizePatterns, sizePattern) {
+
+        if (sizePattern->wWidth != width || sizePattern->wHeight != height)
+          continue;
+
+        still_ctrl->bInterfaceNumber = ctrl->bInterfaceNumber;
+        still_ctrl->bFormatIndex = format->bFormatIndex;
+        still_ctrl->bFrameIndex = sizePattern->bResolutionIndex;
+        still_ctrl->bCompressionIndex = 0; //TODO support compression index
+        goto found;
+      }
+    }
+  }
+
+  return UVC_ERROR_INVALID_MODE;
+
+  found:
+    return uvc_probe_still_ctrl(devh, still_ctrl);
+}
+
+static int _uvc_stream_params_negotiated(
+  uvc_stream_ctrl_t *required,
+  uvc_stream_ctrl_t *actual) {
+    return required->bFormatIndex == actual->bFormatIndex &&
+    required->bFrameIndex == actual->bFrameIndex &&
+    required->dwMaxPayloadTransferSize >= actual->dwMaxPayloadTransferSize;
+}
+
+/** @internal
+ * Negotiate streaming parameters with the device
+ *
+ * @param[in] devh UVC device
+ * @param[in,out] ctrl Control block
+ */
+uvc_error_t uvc_probe_stream_ctrl(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl) {
+  uvc_stream_ctrl_t required_ctrl = *ctrl;
+
+  uvc_query_stream_ctrl( devh, ctrl, 1, UVC_SET_CUR );
+  uvc_query_stream_ctrl( devh, ctrl, 1, UVC_GET_CUR );
+
+  if(!_uvc_stream_params_negotiated(&required_ctrl, ctrl)) {
+    UVC_DEBUG("Unable to negotiate streaming format");
+    return UVC_ERROR_INVALID_MODE;
+  }
+
+  return UVC_SUCCESS;
+}
+
+/** @internal
+ * Negotiate still parameters with the device
+ *
+ * @param[in] devh UVC device
+ * @param[in,out] still_ctrl Still capture control block
+ */
+uvc_error_t uvc_probe_still_ctrl(
+    uvc_device_handle_t *devh,
+    uvc_still_ctrl_t *still_ctrl) {
+
+  int res = uvc_query_still_ctrl(
+    devh, still_ctrl, 1, UVC_SET_CUR
+  );
+
+  if(res == UVC_SUCCESS) {
+    res = uvc_query_still_ctrl(
+      devh, still_ctrl, 1, UVC_GET_CUR
+    );
+
+    if(res == UVC_SUCCESS) {
+      res = uvc_query_still_ctrl(
+        devh, still_ctrl, 0, UVC_SET_CUR
+      );
+    }
+  }
+
+  return res;
+}
+
+/** @internal
+ * @brief Swap the working buffer with the presented buffer and notify consumers
+ */
+void _uvc_swap_buffers(uvc_stream_handle_t *strmh) {
+  uint8_t *tmp_buf;
+
+  pthread_mutex_lock(&strmh->cb_mutex);
+
+  (void)clock_gettime(CLOCK_MONOTONIC, &strmh->capture_time_finished);
+
+  /* swap the buffers */
+  tmp_buf = strmh->holdbuf;
+  strmh->hold_bytes = strmh->got_bytes;
+  strmh->holdbuf = strmh->outbuf;
+  strmh->outbuf = tmp_buf;
+  strmh->hold_last_scr = strmh->last_scr;
+  strmh->hold_pts = strmh->pts;
+  strmh->hold_seq = strmh->seq;
+  
+  /* swap metadata buffer */
+  tmp_buf = strmh->meta_holdbuf;
+  strmh->meta_holdbuf = strmh->meta_outbuf;
+  strmh->meta_outbuf = tmp_buf;
+  strmh->meta_hold_bytes = strmh->meta_got_bytes;
+
+  pthread_cond_broadcast(&strmh->cb_cond);
+  pthread_mutex_unlock(&strmh->cb_mutex);
+
+  strmh->seq++;
+  strmh->got_bytes = 0;
+  strmh->meta_got_bytes = 0;
+  strmh->last_scr = 0;
+  strmh->pts = 0;
+}
+
+/** @internal
+ * @brief Process a payload transfer
+ * 
+ * Processes stream, places frames into buffer, signals listeners
+ * (such as user callback thread and any polling thread) on new frame
+ *
+ * @param payload Contents of the payload transfer, either a packet (isochronous) or a full
+ * transfer (bulk mode)
+ * @param payload_len Length of the payload transfer
+ */
+void _uvc_process_payload(uvc_stream_handle_t *strmh, uint8_t *payload, size_t payload_len) {
+  size_t header_len;
+  uint8_t header_info;
+  size_t data_len;
+
+  /* magic numbers for identifying header packets from some iSight cameras */
+  static uint8_t isight_tag[] = {
+    0x11, 0x22, 0x33, 0x44,
+    0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xfa, 0xce
+  };
+
+  /* ignore empty payload transfers */
+  if (payload_len == 0)
+    return;
+
+  /* Certain iSight cameras have strange behavior: They send header
+   * information in a packet with no image data, and then the following
+   * packets have only image data, with no more headers until the next frame.
+   *
+   * The iSight header: len(1), flags(1 or 2), 0x11223344(4),
+   * 0xdeadbeefdeadface(8), ??(16)
+   */
+
+  if (strmh->devh->is_isight &&
+      (payload_len < 14 || memcmp(isight_tag, payload + 2, sizeof(isight_tag))) &&
+      (payload_len < 15 || memcmp(isight_tag, payload + 3, sizeof(isight_tag)))) {
+    /* The payload transfer doesn't have any iSight magic, so it's all image data */
+    header_len = 0;
+    data_len = payload_len;
+  } else {
+    header_len = payload[0];
+
+    if (header_len > payload_len) {
+      UVC_DEBUG("bogus packet: actual_len=%zd, header_len=%zd\n", payload_len, header_len);
+      return;
+    }
+
+    if (strmh->devh->is_isight)
+      data_len = 0;
+    else
+      data_len = payload_len - header_len;
+  }
+
+  if (header_len < 2) {
+    header_info = 0;
+  } else {
+    /** @todo we should be checking the end-of-header bit */
+    size_t variable_offset = 2;
+
+    header_info = payload[1];
+
+    if (header_info & 0x40) {
+      UVC_DEBUG("bad packet: error bit set");
+      return;
+    }
+
+    if (strmh->fid != (header_info & 1) && strmh->got_bytes != 0) {
+      /* The frame ID bit was flipped, but we have image data sitting
+         around from prior transfers. This means the camera didn't send
+         an EOF for the last transfer of the previous frame. */
+      _uvc_swap_buffers(strmh);
+    }
+
+    strmh->fid = header_info & 1;
+
+    if (header_info & (1 << 2)) {
+      strmh->pts = DW_TO_INT(payload + variable_offset);
+      variable_offset += 4;
+    }
+
+    if (header_info & (1 << 3)) {
+      /** @todo read the SOF token counter */
+      strmh->last_scr = DW_TO_INT(payload + variable_offset);
+      variable_offset += 6;
+    }
+
+    if (header_len > variable_offset) {
+        // Metadata is attached to header
+        size_t meta_len = header_len - variable_offset;
+        if (strmh->meta_got_bytes + meta_len > LIBUVC_XFER_META_BUF_SIZE)
+          meta_len = LIBUVC_XFER_META_BUF_SIZE - strmh->meta_got_bytes; /* Avoid overflow. */
+        memcpy(strmh->meta_outbuf + strmh->meta_got_bytes, payload + variable_offset, meta_len);
+        strmh->meta_got_bytes += meta_len;
+    }
+  }
+
+  if (data_len > 0) {
+    if (strmh->got_bytes + data_len > strmh->cur_ctrl.dwMaxVideoFrameSize)
+      data_len = strmh->cur_ctrl.dwMaxVideoFrameSize - strmh->got_bytes; /* Avoid overflow. */
+    memcpy(strmh->outbuf + strmh->got_bytes, payload + header_len, data_len);
+    strmh->got_bytes += data_len;
+    if (header_info & (1 << 1) || strmh->got_bytes == strmh->cur_ctrl.dwMaxVideoFrameSize) {
+      /* The EOF bit is set, so publish the complete frame */
+      _uvc_swap_buffers(strmh);
+    }
+  }
+}
+
+/** @internal
+ * @brief Stream transfer callback
+ *
+ * Processes stream, places frames into buffer, signals listeners
+ * (such as user callback thread and any polling thread) on new frame
+ *
+ * @param transfer Active transfer
+ */
+void LIBUSB_CALL _uvc_stream_callback(struct libusb_transfer *transfer) {
+  uvc_stream_handle_t *strmh = transfer->user_data;
+
+  int resubmit = 1;
+
+  switch (transfer->status) {
+  case LIBUSB_TRANSFER_COMPLETED:
+    if (transfer->num_iso_packets == 0) {
+      /* This is a bulk mode transfer, so it just has one payload transfer */
+      _uvc_process_payload(strmh, transfer->buffer, transfer->actual_length);
+    } else {
+      /* This is an isochronous mode transfer, so each packet has a payload transfer */
+      int packet_id;
+
+      for (packet_id = 0; packet_id < transfer->num_iso_packets; ++packet_id) {
+        uint8_t *pktbuf;
+        struct libusb_iso_packet_descriptor *pkt;
+
+        pkt = transfer->iso_packet_desc + packet_id;
+
+        if (pkt->status != 0) {
+          UVC_DEBUG("bad packet (isochronous transfer); status: %d", pkt->status);
+          continue;
+        }
+
+        pktbuf = libusb_get_iso_packet_buffer_simple(transfer, packet_id);
+
+        _uvc_process_payload(strmh, pktbuf, pkt->actual_length);
+
+      }
+    }
+    break;
+  case LIBUSB_TRANSFER_CANCELLED: 
+  case LIBUSB_TRANSFER_ERROR:
+  case LIBUSB_TRANSFER_NO_DEVICE: {
+    int i;
+    UVC_DEBUG("not retrying transfer, status = %d", transfer->status);
+    pthread_mutex_lock(&strmh->cb_mutex);
+
+    /* Mark transfer as deleted. */
+    for(i=0; i < LIBUVC_NUM_TRANSFER_BUFS; i++) {
+      if(strmh->transfers[i] == transfer) {
+        UVC_DEBUG("Freeing transfer %d (%p)", i, transfer);
+        free(transfer->buffer);
+        libusb_free_transfer(transfer);
+        strmh->transfers[i] = NULL;
+        break;
+      }
+    }
+    if(i == LIBUVC_NUM_TRANSFER_BUFS ) {
+      UVC_DEBUG("transfer %p not found; not freeing!", transfer);
+    }
+
+    resubmit = 0;
+
+    pthread_cond_broadcast(&strmh->cb_cond);
+    pthread_mutex_unlock(&strmh->cb_mutex);
+
+    break;
+  }
+  case LIBUSB_TRANSFER_TIMED_OUT:
+  case LIBUSB_TRANSFER_STALL:
+  case LIBUSB_TRANSFER_OVERFLOW:
+    UVC_DEBUG("retrying transfer, status = %d", transfer->status);
+    break;
+  }
+  
+  if ( resubmit ) {
+    if ( strmh->running ) {
+      int libusbRet = libusb_submit_transfer(transfer);
+      if (libusbRet < 0)
+      {
+        int i;
+        pthread_mutex_lock(&strmh->cb_mutex);
+
+        /* Mark transfer as deleted. */
+        for (i = 0; i < LIBUVC_NUM_TRANSFER_BUFS; i++) {
+          if (strmh->transfers[i] == transfer) {
+            UVC_DEBUG("Freeing failed transfer %d (%p)", i, transfer);
+            free(transfer->buffer);
+            libusb_free_transfer(transfer);
+            strmh->transfers[i] = NULL;
+            break;
+          }
+        }
+        if (i == LIBUVC_NUM_TRANSFER_BUFS) {
+          UVC_DEBUG("failed transfer %p not found; not freeing!", transfer);
+        }
+
+        pthread_cond_broadcast(&strmh->cb_cond);
+        pthread_mutex_unlock(&strmh->cb_mutex);
+      }
+    } else {
+      int i;
+      pthread_mutex_lock(&strmh->cb_mutex);
+
+      /* Mark transfer as deleted. */
+      for(i=0; i < LIBUVC_NUM_TRANSFER_BUFS; i++) {
+        if(strmh->transfers[i] == transfer) {
+          UVC_DEBUG("Freeing orphan transfer %d (%p)", i, transfer);
+          free(transfer->buffer);
+          libusb_free_transfer(transfer);
+          strmh->transfers[i] = NULL;
+          break;
+        }
+      }
+      if(i == LIBUVC_NUM_TRANSFER_BUFS ) {
+        UVC_DEBUG("orphan transfer %p not found; not freeing!", transfer);
+      }
+
+      pthread_cond_broadcast(&strmh->cb_cond);
+      pthread_mutex_unlock(&strmh->cb_mutex);
+    }
+  }
+}
+
+/** Begin streaming video from the camera into the callback function.
+ * @ingroup streaming
+ *
+ * @param devh UVC device
+ * @param ctrl Control block, processed using {uvc_probe_stream_ctrl} or
+ *             {uvc_get_stream_ctrl_format_size}
+ * @param cb   User callback function. See {uvc_frame_callback_t} for restrictions.
+ * @param flags Stream setup flags, currently undefined. Set this to zero. The lower bit
+ * is reserved for backward compatibility.
+ */
+uvc_error_t uvc_start_streaming(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    uvc_frame_callback_t *cb,
+    void *user_ptr,
+    uint8_t flags
+) {
+  uvc_error_t ret;
+  uvc_stream_handle_t *strmh;
+
+  ret = uvc_stream_open_ctrl(devh, &strmh, ctrl);
+  if (ret != UVC_SUCCESS)
+    return ret;
+
+  ret = uvc_stream_start(strmh, cb, user_ptr, flags);
+  if (ret != UVC_SUCCESS) {
+    uvc_stream_close(strmh);
+    return ret;
+  }
+
+  return UVC_SUCCESS;
+}
+
+/** Begin streaming video from the camera into the callback function.
+ * @ingroup streaming
+ *
+ * @deprecated The stream type (bulk vs. isochronous) will be determined by the
+ * type of interface associated with the uvc_stream_ctrl_t parameter, regardless
+ * of whether the caller requests isochronous streaming. Please switch to
+ * uvc_start_streaming().
+ *
+ * @param devh UVC device
+ * @param ctrl Control block, processed using {uvc_probe_stream_ctrl} or
+ *             {uvc_get_stream_ctrl_format_size}
+ * @param cb   User callback function. See {uvc_frame_callback_t} for restrictions.
+ */
+uvc_error_t uvc_start_iso_streaming(
+    uvc_device_handle_t *devh,
+    uvc_stream_ctrl_t *ctrl,
+    uvc_frame_callback_t *cb,
+    void *user_ptr
+) {
+  return uvc_start_streaming(devh, ctrl, cb, user_ptr, 0);
+}
+
+static uvc_stream_handle_t *_uvc_get_stream_by_interface(uvc_device_handle_t *devh, int interface_idx) {
+  uvc_stream_handle_t *strmh;
+
+  DL_FOREACH(devh->streams, strmh) {
+    if (strmh->stream_if->bInterfaceNumber == interface_idx)
+      return strmh;
+  }
+
+  return NULL;
+}
+
+static uvc_streaming_interface_t *_uvc_get_stream_if(uvc_device_handle_t *devh, int interface_idx) {
+  uvc_streaming_interface_t *stream_if;
+
+  DL_FOREACH(devh->info->stream_ifs, stream_if) {
+    if (stream_if->bInterfaceNumber == interface_idx)
+      return stream_if;
+  }
+  
+  return NULL;
+}
+
+/** Open a new video stream.
+ * @ingroup streaming
+ *
+ * @param devh UVC device
+ * @param ctrl Control block, processed using {uvc_probe_stream_ctrl} or
+ *             {uvc_get_stream_ctrl_format_size}
+ */
+uvc_error_t uvc_stream_open_ctrl(uvc_device_handle_t *devh, uvc_stream_handle_t **strmhp, uvc_stream_ctrl_t *ctrl) {
+  /* Chosen frame and format descriptors */
+  uvc_stream_handle_t *strmh = NULL;
+  uvc_streaming_interface_t *stream_if;
+  uvc_error_t ret;
+
+  UVC_ENTER();
+
+  if (_uvc_get_stream_by_interface(devh, ctrl->bInterfaceNumber) != NULL) {
+    ret = UVC_ERROR_BUSY; /* Stream is already opened */
+    goto fail;
+  }
+
+  stream_if = _uvc_get_stream_if(devh, ctrl->bInterfaceNumber);
+  if (!stream_if) {
+    ret = UVC_ERROR_INVALID_PARAM;
+    goto fail;
+  }
+
+  strmh = calloc(1, sizeof(*strmh));
+  if (!strmh) {
+    ret = UVC_ERROR_NO_MEM;
+    goto fail;
+  }
+  strmh->devh = devh;
+  strmh->stream_if = stream_if;
+  strmh->frame.library_owns_data = 1;
+
+  ret = uvc_claim_if(strmh->devh, strmh->stream_if->bInterfaceNumber);
+  if (ret != UVC_SUCCESS)
+    goto fail;
+
+  ret = uvc_stream_ctrl(strmh, ctrl);
+  if (ret != UVC_SUCCESS)
+    goto fail;
+
+  // Set up the streaming status and data space
+  strmh->running = 0;
+
+  strmh->outbuf = malloc( ctrl->dwMaxVideoFrameSize );
+  strmh->holdbuf = malloc( ctrl->dwMaxVideoFrameSize );
+
+  strmh->meta_outbuf = malloc( LIBUVC_XFER_META_BUF_SIZE );
+  strmh->meta_holdbuf = malloc( LIBUVC_XFER_META_BUF_SIZE );
+   
+  pthread_mutex_init(&strmh->cb_mutex, NULL);
+  pthread_cond_init(&strmh->cb_cond, NULL);
+
+  DL_APPEND(devh->streams, strmh);
+
+  *strmhp = strmh;
+
+  UVC_EXIT(0);
+  return UVC_SUCCESS;
+
+fail:
+  if(strmh)
+    free(strmh);
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/** Begin streaming video from the stream into the callback function.
+ * @ingroup streaming
+ *
+ * @param strmh UVC stream
+ * @param cb   User callback function. See {uvc_frame_callback_t} for restrictions.
+ * @param flags Stream setup flags, currently undefined. Set this to zero. The lower bit
+ * is reserved for backward compatibility.
+ */
+uvc_error_t uvc_stream_start(
+    uvc_stream_handle_t *strmh,
+    uvc_frame_callback_t *cb,
+    void *user_ptr,
+    uint8_t flags
+) {
+  /* USB interface we'll be using */
+  const struct libusb_interface *interface;
+  int interface_id;
+  char isochronous;
+  uvc_frame_desc_t *frame_desc;
+  uvc_format_desc_t *format_desc;
+  uvc_stream_ctrl_t *ctrl;
+  uvc_error_t ret;
+  struct ksq_altsetting_choice choice;
+  /* Total amount of data per transfer */
+  size_t total_transfer_size = 0;
+  struct libusb_transfer *transfer;
+  int transfer_id;
+
+  ctrl = &strmh->cur_ctrl;
+
+  UVC_ENTER();
+
+  if (strmh->running) {
+    UVC_EXIT(UVC_ERROR_BUSY);
+    return UVC_ERROR_BUSY;
+  }
+
+  strmh->running = 1;
+  strmh->seq = 1;
+  strmh->fid = 0;
+  strmh->pts = 0;
+  strmh->last_scr = 0;
+
+  frame_desc = uvc_find_frame_desc_stream(strmh, ctrl->bFormatIndex, ctrl->bFrameIndex);
+  if (!frame_desc) {
+    ret = UVC_ERROR_INVALID_PARAM;
+    goto fail;
+  }
+  format_desc = frame_desc->parent;
+
+  strmh->frame_format = uvc_frame_format_for_guid(format_desc->guidFormat);
+  if (strmh->frame_format == UVC_FRAME_FORMAT_UNKNOWN) {
+    ret = UVC_ERROR_NOT_SUPPORTED;
+    goto fail;
+  }
+
+  // Get the interface that provides the chosen format and frame configuration
+  interface_id = strmh->stream_if->bInterfaceNumber;
+  interface = &strmh->devh->info->config->interface[interface_id];
+
+  /* A VS interface uses isochronous transfers iff it has multiple altsettings.
+   * (UVC 1.5: 2.4.3. VideoStreaming Interface) */
+  isochronous = interface->num_altsetting > 1;
+
+  if (isochronous) {
+    /* For isochronous streaming, we choose an appropriate altsetting for the endpoint
+     * and set up several transfers */
+    const struct libusb_interface_descriptor *altsetting = 0;
+    const struct libusb_endpoint_descriptor *endpoint = 0;
+    /* The greatest number of bytes that the device might provide, per packet, in this
+     * configuration */
+    size_t config_bytes_per_packet;
+    /* Number of packets per transfer */
+    size_t packets_per_transfer = 0;
+    /* Size of packet transferable from the chosen endpoint */
+    size_t endpoint_bytes_per_packet = 0;
+    /* Index of the altsetting */
+    int alt_idx, ep_idx;
+    const struct ksq_altsetting_quirk *quirk;
+    
+    config_bytes_per_packet = strmh->cur_ctrl.dwMaxPayloadTransferSize;
+
+    /* Go through the altsettings and find one whose packets are at least
+     * as big as our format's maximum per-packet usage. Assume that the
+     * packet sizes are increasing. */
+    for (alt_idx = 0; alt_idx < interface->num_altsetting; alt_idx++) {
+      altsetting = interface->altsetting + alt_idx;
+      endpoint_bytes_per_packet = 0;
+
+      /* Find the endpoint with the number specified in the VS header */
+      for (ep_idx = 0; ep_idx < altsetting->bNumEndpoints; ep_idx++) {
+        endpoint = altsetting->endpoint + ep_idx;
+
+        struct libusb_ss_endpoint_companion_descriptor *ep_comp = 0;
+        libusb_get_ss_endpoint_companion_descriptor(NULL, endpoint, &ep_comp);
+        if (ep_comp)
+        {
+          endpoint_bytes_per_packet = ep_comp->wBytesPerInterval;
+          libusb_free_ss_endpoint_companion_descriptor(ep_comp);
+          break;
+        }
+        else
+        {
+          if (endpoint->bEndpointAddress == format_desc->parent->bEndpointAddress) {
+              endpoint_bytes_per_packet = endpoint->wMaxPacketSize;
+            // wMaxPacketSize: [unused:2 (multiplier-1):3 size:11]
+            endpoint_bytes_per_packet = (endpoint_bytes_per_packet & 0x07ff) *
+              (((endpoint_bytes_per_packet >> 11) & 3) + 1);
+            break;
+          }
+        }
+      }
+
+      if (endpoint_bytes_per_packet >= config_bytes_per_packet) {
+        /* Transfers will be at most one frame long: Divide the maximum frame size
+         * by the size of the endpoint and round up */
+        packets_per_transfer = (ctrl->dwMaxVideoFrameSize +
+                                endpoint_bytes_per_packet - 1) / endpoint_bytes_per_packet;
+
+        /* But keep a reasonable limit: Otherwise we start dropping data */
+        if (packets_per_transfer > 32)
+          packets_per_transfer = 32;
+        
+        total_transfer_size = packets_per_transfer * endpoint_bytes_per_packet;
+        break;
+      }
+    }
+
+    if (_ksq_resolve_altsetting_for_ctrl(strmh->devh, ctrl, strmh->frame_format,
+                                         frame_desc, &choice)) {
+      int forced_alt_idx = -1;
+
+      for (alt_idx = 0; alt_idx < interface->num_altsetting; ++alt_idx) {
+        const struct libusb_interface_descriptor *candidate =
+            interface->altsetting + alt_idx;
+        if (candidate->bAlternateSetting == choice.altsetting) {
+          forced_alt_idx = alt_idx;
+          altsetting = candidate;
+          endpoint_bytes_per_packet = 0;
+          for (ep_idx = 0; ep_idx < candidate->bNumEndpoints; ++ep_idx) {
+            endpoint = candidate->endpoint + ep_idx;
+            if (endpoint->bEndpointAddress ==
+                format_desc->parent->bEndpointAddress) {
+              endpoint_bytes_per_packet = endpoint->wMaxPacketSize;
+              endpoint_bytes_per_packet =
+                  (endpoint_bytes_per_packet & 0x07ff) *
+                  (((endpoint_bytes_per_packet >> 11) & 3) + 1);
+              break;
+            }
+          }
+          break;
+        }
+      }
+
+      if (forced_alt_idx < 0 ||
+          endpoint_bytes_per_packet < choice.payload) {
+        fprintf(stderr,
+                "[LIBUVC-QUIRK] VID:PID %04x:%04x alt=%u "
+                "payload=%u unavailable endpoint=%zu%s\n",
+                choice.vid, choice.pid,
+                choice.altsetting, choice.payload,
+                endpoint_bytes_per_packet,
+                choice.from_override ? " (altsetting override)" : "");
+        ret = UVC_ERROR_INVALID_MODE;
+        goto fail;
+      }
+
+      /* Recompute transfer geometry for the forced endpoint. */
+      packets_per_transfer = (ctrl->dwMaxVideoFrameSize +
+                              endpoint_bytes_per_packet - 1) /
+                             endpoint_bytes_per_packet;
+      if (packets_per_transfer > 32)
+        packets_per_transfer = 32;
+      total_transfer_size = packets_per_transfer * endpoint_bytes_per_packet;
+      fprintf(stderr,
+              "[LIBUVC-QUIRK] VID:PID %04x:%04x alt=%u "
+              "payload=%u endpoint=%zu frame=%ux%u interval=%u"
+              " xfers=%d xfer_bytes=%zu%s\n",
+              choice.vid, choice.pid,
+              choice.altsetting, choice.payload,
+              endpoint_bytes_per_packet, frame_desc->wWidth,
+              frame_desc->wHeight, ctrl->dwFrameInterval,
+              packets_per_transfer, total_transfer_size,
+              choice.from_override ? " (altsetting override)" : "");
+      alt_idx = forced_alt_idx;
+    }
+
+    /* If we searched through all the altsettings and found nothing usable */
+    if (alt_idx == interface->num_altsetting) {
+      ret = UVC_ERROR_INVALID_MODE;
+      goto fail;
+    }
+
+    /* Select the altsetting */
+    ret = libusb_set_interface_alt_setting(strmh->devh->usb_devh,
+                                           altsetting->bInterfaceNumber,
+                                           altsetting->bAlternateSetting);
+    if (ret != UVC_SUCCESS) {
+      UVC_DEBUG("libusb_set_interface_alt_setting failed");
+      goto fail;
+    }
+
+    /* Set up the transfers */
+    for (transfer_id = 0; transfer_id < LIBUVC_NUM_TRANSFER_BUFS; ++transfer_id) {
+      transfer = libusb_alloc_transfer(packets_per_transfer);
+      strmh->transfers[transfer_id] = transfer;      
+      strmh->transfer_bufs[transfer_id] = malloc(total_transfer_size);
+
+      libusb_fill_iso_transfer(
+        transfer, strmh->devh->usb_devh, format_desc->parent->bEndpointAddress,
+        strmh->transfer_bufs[transfer_id],
+        total_transfer_size, packets_per_transfer, _uvc_stream_callback, (void*) strmh, 5000);
+
+      libusb_set_iso_packet_lengths(transfer, endpoint_bytes_per_packet);
+    }
+  } else {
+    for (transfer_id = 0; transfer_id < LIBUVC_NUM_TRANSFER_BUFS;
+        ++transfer_id) {
+      transfer = libusb_alloc_transfer(0);
+      strmh->transfers[transfer_id] = transfer;
+      strmh->transfer_bufs[transfer_id] = malloc (
+          strmh->cur_ctrl.dwMaxPayloadTransferSize );
+      libusb_fill_bulk_transfer ( transfer, strmh->devh->usb_devh,
+          format_desc->parent->bEndpointAddress,
+          strmh->transfer_bufs[transfer_id],
+          strmh->cur_ctrl.dwMaxPayloadTransferSize, _uvc_stream_callback,
+          ( void* ) strmh, 5000 );
+    }
+  }
+
+  strmh->user_cb = cb;
+  strmh->user_ptr = user_ptr;
+
+  /* If the user wants it, set up a thread that calls the user's function
+   * with the contents of each frame.
+   */
+  if (cb) {
+    pthread_create(&strmh->cb_thread, NULL, _uvc_user_caller, (void*) strmh);
+  }
+
+  for (transfer_id = 0; transfer_id < LIBUVC_NUM_TRANSFER_BUFS;
+      transfer_id++) {
+    ret = libusb_submit_transfer(strmh->transfers[transfer_id]);
+    if (ret != UVC_SUCCESS) {
+      UVC_DEBUG("libusb_submit_transfer failed: %d",ret);
+      break;
+    }
+  }
+
+  if ( ret != UVC_SUCCESS && transfer_id >= 0 ) {
+    for ( ; transfer_id < LIBUVC_NUM_TRANSFER_BUFS; transfer_id++) {
+      free ( strmh->transfers[transfer_id]->buffer );
+      libusb_free_transfer ( strmh->transfers[transfer_id]);
+      strmh->transfers[transfer_id] = 0;
+    }
+    ret = UVC_SUCCESS;
+  }
+
+  UVC_EXIT(ret);
+  return ret;
+fail:
+  strmh->running = 0;
+  UVC_EXIT(ret);
+  return ret;
+}
+
+/** Begin streaming video from the stream into the callback function.
+ * @ingroup streaming
+ *
+ * @deprecated The stream type (bulk vs. isochronous) will be determined by the
+ * type of interface associated with the uvc_stream_ctrl_t parameter, regardless
+ * of whether the caller requests isochronous streaming. Please switch to
+ * uvc_stream_start().
+ *
+ * @param strmh UVC stream
+ * @param cb   User callback function. See {uvc_frame_callback_t} for restrictions.
+ */
+uvc_error_t uvc_stream_start_iso(
+    uvc_stream_handle_t *strmh,
+    uvc_frame_callback_t *cb,
+    void *user_ptr
+) {
+  return uvc_stream_start(strmh, cb, user_ptr, 0);
+}
+
+/** @internal
+ * @brief User callback runner thread
+ * @note There should be at most one of these per currently streaming device
+ * @param arg Device handle
+ */
+void *_uvc_user_caller(void *arg) {
+  uvc_stream_handle_t *strmh = (uvc_stream_handle_t *) arg;
+
+  uint32_t last_seq = 0;
+
+  do {
+    pthread_mutex_lock(&strmh->cb_mutex);
+
+    while (strmh->running && last_seq == strmh->hold_seq) {
+      pthread_cond_wait(&strmh->cb_cond, &strmh->cb_mutex);
+    }
+
+    if (!strmh->running) {
+      pthread_mutex_unlock(&strmh->cb_mutex);
+      break;
+    }
+    
+    last_seq = strmh->hold_seq;
+    _uvc_populate_frame(strmh);
+    
+    pthread_mutex_unlock(&strmh->cb_mutex);
+    
+    strmh->user_cb(&strmh->frame, strmh->user_ptr);
+  } while(1);
+
+  return NULL; // return value ignored
+}
+
+/** @internal
+ * @brief Populate the fields of a frame to be handed to user code
+ * must be called with stream cb lock held!
+ */
+void _uvc_populate_frame(uvc_stream_handle_t *strmh) {
+  uvc_frame_t *frame = &strmh->frame;
+  uvc_frame_desc_t *frame_desc;
+
+  /** @todo this stuff that hits the main config cache should really happen
+   * in start() so that only one thread hits these data. all of this stuff
+   * is going to be reopen_on_change anyway
+   */
+
+  frame_desc = uvc_find_frame_desc(strmh->devh, strmh->cur_ctrl.bFormatIndex,
+				   strmh->cur_ctrl.bFrameIndex);
+
+  frame->frame_format = strmh->frame_format;
+  
+  frame->width = frame_desc->wWidth;
+  frame->height = frame_desc->wHeight;
+  
+  switch (frame->frame_format) {
+  case UVC_FRAME_FORMAT_BGR:
+    frame->step = frame->width * 3;
+    break;
+  case UVC_FRAME_FORMAT_YUYV:
+    frame->step = frame->width * 2;
+    break;
+  case UVC_FRAME_FORMAT_NV12:
+    frame->step = frame->width;
+    break;
+  case UVC_FRAME_FORMAT_P010:
+    frame->step = frame->width * 2;
+        break;
+  case UVC_FRAME_FORMAT_MJPEG:
+    frame->step = 0;
+    break;
+  case UVC_FRAME_FORMAT_H264:
+    frame->step = 0;
+    break;
+  default:
+    frame->step = 0;
+    break;
+  }
+
+  frame->sequence = strmh->hold_seq;
+  frame->capture_time_finished = strmh->capture_time_finished;
+
+  /* copy the image data from the hold buffer to the frame (unnecessary extra buf?) */
+  if (frame->data_bytes < strmh->hold_bytes) {
+    frame->data = realloc(frame->data, strmh->hold_bytes);
+  }
+  frame->data_bytes = strmh->hold_bytes;
+  memcpy(frame->data, strmh->holdbuf, frame->data_bytes);
+
+  if (strmh->meta_hold_bytes > 0)
+  {
+      if (frame->metadata_bytes < strmh->meta_hold_bytes)
+      {
+          frame->metadata = realloc(frame->metadata, strmh->meta_hold_bytes);
+      }
+      frame->metadata_bytes = strmh->meta_hold_bytes;
+      memcpy(frame->metadata, strmh->meta_holdbuf, frame->metadata_bytes);
+  }
+}
+
+/** Poll for a frame
+ * @ingroup streaming
+ *
+ * @param devh UVC device
+ * @param[out] frame Location to store pointer to captured frame (NULL on error)
+ * @param timeout_us >0: Wait at most N microseconds; 0: Wait indefinitely; -1: return immediately
+ */
+uvc_error_t uvc_stream_get_frame(uvc_stream_handle_t *strmh,
+			  uvc_frame_t **frame,
+			  int32_t timeout_us) {
+  time_t add_secs;
+  time_t add_nsecs;
+  struct timespec ts;
+
+  if (!strmh->running)
+    return UVC_ERROR_INVALID_PARAM;
+
+  if (strmh->user_cb)
+    return UVC_ERROR_CALLBACK_EXISTS;
+
+  pthread_mutex_lock(&strmh->cb_mutex);
+
+  if (strmh->last_polled_seq < strmh->hold_seq) {
+    _uvc_populate_frame(strmh);
+    *frame = &strmh->frame;
+    strmh->last_polled_seq = strmh->hold_seq;
+  } else if (timeout_us != -1) {
+    if (timeout_us == 0) {
+      pthread_cond_wait(&strmh->cb_cond, &strmh->cb_mutex);
+    } else {
+      add_secs = timeout_us / 1000000;
+      add_nsecs = (timeout_us % 1000000) * 1000;
+      ts.tv_sec = 0;
+      ts.tv_nsec = 0;
+
+#if _POSIX_TIMERS > 0
+      clock_gettime(CLOCK_REALTIME, &ts);
+#else
+      struct timeval tv;
+      gettimeofday(&tv, NULL);
+      ts.tv_sec = tv.tv_sec;
+      ts.tv_nsec = tv.tv_usec * 1000;
+#endif
+
+      ts.tv_sec += add_secs;
+      ts.tv_nsec += add_nsecs;
+
+      /* pthread_cond_timedwait FAILS with EINVAL if ts.tv_nsec > 1000000000 (1 billion)
+       * Since we are just adding values to the timespec, we have to increment the seconds if nanoseconds is greater than 1 billion,
+       * and then re-adjust the nanoseconds in the correct range.
+       * */
+      ts.tv_sec += ts.tv_nsec / 1000000000;
+      ts.tv_nsec = ts.tv_nsec % 1000000000;
+
+      int err = pthread_cond_timedwait(&strmh->cb_cond, &strmh->cb_mutex, &ts);
+
+      //TODO: How should we handle EINVAL?
+      if (err) {
+        *frame = NULL;
+        pthread_mutex_unlock(&strmh->cb_mutex);
+        return err == ETIMEDOUT ? UVC_ERROR_TIMEOUT : UVC_ERROR_OTHER;
+      }
+    }
+    
+    if (strmh->last_polled_seq < strmh->hold_seq) {
+      _uvc_populate_frame(strmh);
+      *frame = &strmh->frame;
+      strmh->last_polled_seq = strmh->hold_seq;
+    } else {
+      *frame = NULL;
+    }
+  } else {
+    *frame = NULL;
+  }
+
+  pthread_mutex_unlock(&strmh->cb_mutex);
+
+  return UVC_SUCCESS;
+}
+
+/** @brief Stop streaming video
+ * @ingroup streaming
+ *
+ * Closes all streams, ends threads and cancels pollers
+ *
+ * @param devh UVC device
+ */
+void uvc_stop_streaming(uvc_device_handle_t *devh) {
+  uvc_stream_handle_t *strmh, *strmh_tmp;
+
+  DL_FOREACH_SAFE(devh->streams, strmh, strmh_tmp) {
+    uvc_stream_close(strmh);
+  }
+}
+
+/** @brief Stop stream.
+ * @ingroup streaming
+ *
+ * Stops stream, ends threads and cancels pollers
+ *
+ * @param devh UVC device
+ */
+uvc_error_t uvc_stream_stop(uvc_stream_handle_t *strmh) {
+  int i;
+
+  if (!strmh->running)
+    return UVC_ERROR_INVALID_PARAM;
+
+  strmh->running = 0;
+
+  pthread_mutex_lock(&strmh->cb_mutex);
+
+  /* Attempt to cancel any running transfers, we can't free them just yet because they aren't
+   *   necessarily completed but they will be free'd in _uvc_stream_callback().
+   */
+  for(i=0; i < LIBUVC_NUM_TRANSFER_BUFS; i++) {
+    if(strmh->transfers[i] != NULL)
+      libusb_cancel_transfer(strmh->transfers[i]);
+  }
+
+  /* Wait for transfers to complete/cancel */
+  do {
+    for(i=0; i < LIBUVC_NUM_TRANSFER_BUFS; i++) {
+      if(strmh->transfers[i] != NULL)
+        break;
+    }
+    if(i == LIBUVC_NUM_TRANSFER_BUFS )
+      break;
+    pthread_cond_wait(&strmh->cb_cond, &strmh->cb_mutex);
+  } while(1);
+  // Kick the user thread awake
+  pthread_cond_broadcast(&strmh->cb_cond);
+  pthread_mutex_unlock(&strmh->cb_mutex);
+
+  /** @todo stop the actual stream, camera side? */
+
+  if (strmh->user_cb) {
+    /* wait for the thread to stop (triggered by
+     * LIBUSB_TRANSFER_CANCELLED transfer) */
+    pthread_join(strmh->cb_thread, NULL);
+  }
+
+  return UVC_SUCCESS;
+}
+
+/** @brief Close stream.
+ * @ingroup streaming
+ *
+ * Closes stream, frees handle and all streaming resources.
+ *
+ * @param strmh UVC stream handle
+ */
+void uvc_stream_close(uvc_stream_handle_t *strmh) {
+  if (strmh->running)
+    uvc_stream_stop(strmh);
+
+  uvc_release_if(strmh->devh, strmh->stream_if->bInterfaceNumber);
+
+  if (strmh->frame.data)
+    free(strmh->frame.data);
+
+  free(strmh->outbuf);
+  free(strmh->holdbuf);
+
+  free(strmh->meta_outbuf);
+  free(strmh->meta_holdbuf);
+
+  pthread_cond_destroy(&strmh->cb_cond);
+  pthread_mutex_destroy(&strmh->cb_mutex);
+
+  DL_DELETE(strmh->devh->streams, strmh);
+  free(strmh);
+}

collector/core/gripper/camera_service_src/third_party/libuvc/src/test.c

@@ -0,0 +1,153 @@
+/*********************************************************************
+* Software License Agreement (BSD License)
+*
+*  Copyright (C) 2010-2012 Ken Tossell
+*  All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions
+*  are met:
+*
+*   * Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*   * Redistributions in binary form must reproduce the above
+*     copyright notice, this list of conditions and the following
+*     disclaimer in the documentation and/or other materials provided
+*     with the distribution.
+*   * Neither the name of the author nor other contributors may be
+*     used to endorse or promote products derived from this software
+*     without specific prior written permission.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+*  POSSIBILITY OF SUCH DAMAGE.
+*********************************************************************/
+#include <stdio.h>
+#include <opencv2/highgui/highgui_c.h>
+
+#include "libuvc/libuvc.h"
+
+void cb(uvc_frame_t *frame, void *ptr) {
+  uvc_frame_t *bgr;
+  uvc_error_t ret;
+  IplImage* cvImg;
+
+  printf("callback! length = %u, ptr = %d\n", frame->data_bytes, (int) ptr);
+
+  bgr = uvc_allocate_frame(frame->width * frame->height * 3);
+  if (!bgr) {
+    printf("unable to allocate bgr frame!");
+    return;
+  }
+
+  ret = uvc_any2bgr(frame, bgr);
+  if (ret) {
+    uvc_perror(ret, "uvc_any2bgr");
+    uvc_free_frame(bgr);
+    return;
+  }
+
+  cvImg = cvCreateImageHeader(
+      cvSize(bgr->width, bgr->height),
+      IPL_DEPTH_8U,
+      3);
+
+  cvSetData(cvImg, bgr->data, bgr->width * 3); 
+
+  cvNamedWindow("Test", CV_WINDOW_AUTOSIZE);
+  cvShowImage("Test", cvImg);
+  cvWaitKey(10);
+
+  cvReleaseImageHeader(&cvImg);
+
+  uvc_free_frame(bgr);
+}
+
+int main(int argc, char **argv) {
+  uvc_context_t *ctx;
+  uvc_error_t res;
+  uvc_device_t *dev;
+  uvc_device_handle_t *devh;
+  uvc_stream_ctrl_t ctrl;
+
+  res = uvc_init(&ctx, NULL);
+
+  if (res < 0) {
+    uvc_perror(res, "uvc_init");
+    return res;
+  }
+
+  puts("UVC initialized");
+
+  res = uvc_find_device(
+      ctx, &dev,
+      0, 0, NULL);
+
+  if (res < 0) {
+    uvc_perror(res, "uvc_find_device");
+  } else {
+    puts("Device found");
+
+    res = uvc_open(dev, &devh);
+
+    if (res < 0) {
+      uvc_perror(res, "uvc_open");
+    } else {
+      puts("Device opened");
+
+      uvc_print_diag(devh, stderr);
+
+      res = uvc_get_stream_ctrl_format_size(
+          devh, &ctrl, UVC_FRAME_FORMAT_YUYV, 640, 480, 30
+      );
+
+      uvc_print_stream_ctrl(&ctrl, stderr);
+
+      if (res < 0) {
+        uvc_perror(res, "get_mode");
+      } else {
+        res = uvc_start_streaming(devh, &ctrl, cb, 12345, 0);
+
+        if (res < 0) {
+          uvc_perror(res, "start_streaming");
+        } else {
+          puts("Streaming for 10 seconds...");
+          uvc_error_t resAEMODE = uvc_set_ae_mode(devh, 1);
+          uvc_perror(resAEMODE, "set_ae_mode");
+          int i;
+          for (i = 1; i <= 10; i++) {
+            /* uvc_error_t resPT = uvc_set_pantilt_abs(devh, i * 20 * 3600, 0); */
+            /* uvc_perror(resPT, "set_pt_abs"); */
+            uvc_error_t resEXP = uvc_set_exposure_abs(devh, 20 + i * 5);
+            uvc_perror(resEXP, "set_exp_abs");
+            
+            sleep(1);
+          }
+          sleep(10);
+          uvc_stop_streaming(devh);
+	  puts("Done streaming.");
+        }
+      }
+
+      uvc_close(devh);
+      puts("Device closed");
+    }
+
+    uvc_unref_device(dev);
+  }
+
+  uvc_exit(ctx);
+  puts("UVC exited");
+
+  return 0;
+}
+

collector/core/gripper/camera_service_src/third_party/libuvc/standard-units.yaml

@@ -0,0 +1,518 @@
+units:
+  camera_terminal:
+    type: standard
+    description: Standard camera input terminal (captures images from sensor)
+    control_prefix: CT
+    controls:
+      scanning_mode:
+        control: SCANNING_MODE
+        length: 1
+        fields:
+          mode:
+            type: int
+            position: 0
+            length: 1
+            doc: '0: interlaced, 1: progressive'
+      ae_mode:
+        control: AE_MODE
+        length: 1
+        fields:
+          mode:
+            type: int
+            position: 0
+            length: 1
+            doc: '1: manual mode; 2: auto mode; 4: shutter priority mode; 8: aperture
+              priority mode'
+        doc:
+          get: |-
+            @brief Reads camera's auto-exposure mode.
+
+            See uvc_set_ae_mode() for a description of the available modes.
+          set: |-
+            @brief Sets camera's auto-exposure mode.
+
+            Cameras may support any of the following AE modes:
+             * UVC_AUTO_EXPOSURE_MODE_MANUAL (1) - manual exposure time, manual iris
+             * UVC_AUTO_EXPOSURE_MODE_AUTO (2) - auto exposure time, auto iris
+             * UVC_AUTO_EXPOSURE_MODE_SHUTTER_PRIORITY (4) - manual exposure time, auto iris
+             * UVC_AUTO_EXPOSURE_MODE_APERTURE_PRIORITY (8) - auto exposure time, manual iris
+
+            Most cameras provide manual mode and aperture priority mode.
+      ae_priority:
+        control: AE_PRIORITY
+        length: 1
+        fields:
+          priority:
+            type: int
+            position: 0
+            length: 1
+            doc: '0: frame rate must remain constant; 1: frame rate may be varied
+              for AE purposes'
+        doc:
+          get: |-
+            @brief Checks whether the camera may vary the frame rate for exposure control reasons.
+            See uvc_set_ae_priority() for a description of the `priority` field.
+          set: |-
+            @brief Chooses whether the camera may vary the frame rate for exposure control reasons.
+            A `priority` value of zero means the camera may not vary its frame rate. A value of 1
+            means the frame rate is variable. This setting has no effect outside of the `auto` and
+            `shutter_priority` auto-exposure modes.
+      exposure_abs:
+        control: EXPOSURE_TIME_ABSOLUTE
+        length: 4
+        fields:
+          time:
+            type: int
+            position: 0
+            length: 4
+            doc: ''
+        doc:
+          get: |-
+            @brief Gets the absolute exposure time.
+
+            See uvc_set_exposure_abs() for a description of the `time` field.
+          set: |-
+            @brief Sets the absolute exposure time.
+
+            The `time` parameter should be provided in units of 0.0001 seconds (e.g., use the value 100
+            for a 10ms exposure period). Auto exposure should be set to `manual` or `shutter_priority`
+            before attempting to change this setting.
+      exposure_rel:
+        control: EXPOSURE_TIME_RELATIVE
+        length: 1
+        fields:
+          step:
+            type: int
+            position: 0
+            length: 1
+            signed: true
+            doc: number of steps by which to change the exposure time, or zero to
+              set the default exposure time
+        doc: '@brief {gets_sets} the exposure time relative to the current setting.'
+      focus_abs:
+        control: FOCUS_ABSOLUTE
+        length: 2
+        fields:
+          focus:
+            type: int
+            position: 0
+            length: 2
+            doc: focal target distance in millimeters
+        doc: '@brief {gets_sets} the distance at which an object is optimally focused.'
+      focus_rel:
+        control: FOCUS_RELATIVE
+        length: 2
+        fields:
+          focus_rel:
+            type: int
+            position: 0
+            length: 1
+            signed: true
+            doc: TODO
+          speed:
+            type: int
+            position: 1
+            length: 1
+            doc: TODO
+      focus_simple_range:
+        control: FOCUS_SIMPLE
+        length: 1
+        fields:
+          focus:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      focus_auto:
+        control: FOCUS_AUTO
+        length: 1
+        fields:
+          state:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      iris_abs:
+        control: IRIS_ABSOLUTE
+        length: 2
+        fields:
+          iris:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      iris_rel:
+        control: IRIS_RELATIVE
+        length: 1
+        fields:
+          iris_rel:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      zoom_abs:
+        control: ZOOM_ABSOLUTE
+        length: 2
+        fields:
+          focal_length:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      zoom_rel:
+        control: ZOOM_RELATIVE
+        length: 3
+        fields:
+          zoom_rel:
+            type: int
+            position: 0
+            length: 1
+            signed: true
+            doc: TODO
+          digital_zoom:
+            type: int
+            position: 1
+            length: 1
+            doc: TODO
+          speed:
+            type: int
+            position: 2
+            length: 1
+            doc: TODO
+      pantilt_abs:
+        control: PANTILT_ABSOLUTE
+        length: 8
+        fields:
+          pan:
+            type: int
+            position: 0
+            length: 4
+            signed: true
+            doc: TODO
+          tilt:
+            type: int
+            position: 4
+            length: 4
+            signed: true
+            doc: TODO
+      pantilt_rel:
+        control: PANTILT_RELATIVE
+        length: 4
+        fields:
+          pan_rel:
+            type: int
+            position: 0
+            length: 1
+            signed: true
+            doc: TODO
+          pan_speed:
+            type: int
+            position: 1
+            length: 1
+            doc: TODO
+          tilt_rel:
+            type: int
+            position: 2
+            length: 1
+            signed: true
+            doc: TODO
+          tilt_speed:
+            type: int
+            position: 3
+            length: 1
+            doc: TODO
+      roll_abs:
+        control: ROLL_ABSOLUTE
+        length: 2
+        fields:
+          roll:
+            type: int
+            position: 0
+            length: 2
+            signed: true
+            doc: TODO
+      roll_rel:
+        control: ROLL_RELATIVE
+        length: 2
+        fields:
+          roll_rel:
+            type: int
+            position: 0
+            length: 1
+            signed: true
+            doc: TODO
+          speed:
+            type: int
+            position: 1
+            length: 1
+            doc: TODO
+      privacy:
+        control: PRIVACY
+        length: 1
+        fields:
+          privacy:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      digital_window:
+        control: DIGITAL_WINDOW
+        length: 12
+        fields:
+          window_top:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+          window_left:
+            type: int
+            position: 2
+            length: 2
+            doc: TODO
+          window_bottom:
+            type: int
+            position: 4
+            length: 2
+            doc: TODO
+          window_right:
+            type: int
+            position: 6
+            length: 2
+            doc: TODO
+          num_steps:
+            type: int
+            position: 8
+            length: 2
+            doc: TODO
+          num_steps_units:
+            type: int
+            position: 10
+            length: 2
+            doc: TODO
+      digital_roi:
+        control: REGION_OF_INTEREST
+        length: 10
+        fields:
+          roi_top:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+          roi_left:
+            type: int
+            position: 2
+            length: 2
+            doc: TODO
+          roi_bottom:
+            type: int
+            position: 4
+            length: 2
+            doc: TODO
+          roi_right:
+            type: int
+            position: 6
+            length: 2
+            doc: TODO
+          auto_controls:
+            type: int
+            position: 8
+            length: 2
+            doc: TODO
+  processing_unit:
+    type: standard
+    description: Standard processing unit (processes images between other units)
+    control_prefix: PU
+    controls:
+      backlight_compensation:
+        control: BACKLIGHT_COMPENSATION
+        length: 2
+        fields:
+          backlight_compensation:
+            type: int
+            position: 0
+            length: 2
+            doc: device-dependent backlight compensation mode; zero means backlight
+              compensation is disabled
+      brightness:
+        control: BRIGHTNESS
+        length: 2
+        fields:
+          brightness:
+            type: int
+            position: 0
+            length: 2
+            signed: true
+            doc: TODO
+      contrast:
+        control: CONTRAST
+        length: 2
+        fields:
+          contrast:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      contrast_auto:
+        control: CONTRAST_AUTO
+        length: 1
+        fields:
+          contrast_auto:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      gain:
+        control: GAIN
+        length: 2
+        fields:
+          gain:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      power_line_frequency:
+        control: POWER_LINE_FREQUENCY
+        length: 1
+        fields:
+          power_line_frequency:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      hue:
+        control: HUE
+        length: 2
+        fields:
+          hue:
+            type: int
+            position: 0
+            length: 2
+            signed: true
+            doc: TODO
+      hue_auto:
+        control: HUE_AUTO
+        length: 1
+        fields:
+          hue_auto:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      saturation:
+        control: SATURATION
+        length: 2
+        fields:
+          saturation:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      sharpness:
+        control: SHARPNESS
+        length: 2
+        fields:
+          sharpness:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      gamma:
+        control: GAMMA
+        length: 2
+        fields:
+          gamma:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      white_balance_temperature:
+        control: WHITE_BALANCE_TEMPERATURE
+        length: 2
+        fields:
+          temperature:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      white_balance_temperature_auto:
+        control: WHITE_BALANCE_TEMPERATURE_AUTO
+        length: 1
+        fields:
+          temperature_auto:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      white_balance_component:
+        control: WHITE_BALANCE_COMPONENT
+        length: 4
+        fields:
+          blue:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+          red:
+            type: int
+            position: 2
+            length: 2
+            doc: TODO
+      white_balance_component_auto:
+        control: WHITE_BALANCE_COMPONENT_AUTO
+        length: 1
+        fields:
+          white_balance_component_auto:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      digital_multiplier:
+        control: DIGITAL_MULTIPLIER
+        length: 2
+        fields:
+          multiplier_step:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      digital_multiplier_limit:
+        control: DIGITAL_MULTIPLIER_LIMIT
+        length: 2
+        fields:
+          multiplier_step:
+            type: int
+            position: 0
+            length: 2
+            doc: TODO
+      analog_video_standard:
+        control: ANALOG_VIDEO_STANDARD
+        length: 1
+        fields:
+          video_standard:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+      analog_video_lock_status:
+        control: ANALOG_LOCK_STATUS
+        length: 1
+        fields:
+          status:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO
+  selector_unit:
+    type: standard
+    description: Standard selector unit (controls connectivity between other units)
+    control_prefix: SU
+    controls:
+      input_select:
+        control: INPUT_SELECT
+        length: 1
+        fields:
+          selector:
+            type: int
+            position: 0
+            length: 1
+            doc: TODO

collector/core/gripper/camera_service_src/tools/discover_uvc_config.c

@@ -0,0 +1,1463 @@
+/*
+ * Minimal user-space discovery demo for Sightac + DECXIN.
+ *
+ * Scope is intentionally limited to:
+ *   Sightac: 0c45:636f, 640x480 MJPEG @ 30
+ *   DECXIN : 1bcf:2d4f, 1280x960 MJPEG @ 30
+ *
+ * Fays is not enumerated as a supported candidate and is never opened by
+ * this program.  The demo uses libuvc for UVC enumeration/negotiation and
+ * libusb for USB topology/descriptors and the read-only Sonix XU6 probe.
+ * It does not start a video stream and it does not write/erase Flash.
+ */
+#include <ctype.h>
+#include <errno.h>
+#include <libusb-1.0/libusb.h>
+#include <libuvc/libuvc.h>
+#include <limits.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define MAX_CANDIDATES 32
+#define MAX_GROUPS 16
+#define MAX_PORT_PATH 64
+#define MAX_TEXT 128
+
+#define SIGHTAC_VID 0x0c45
+#define SIGHTAC_PID 0x636f
+#define DECXIN_VID 0x1bcf
+#define DECXIN_PID 0x2d4f
+
+#define XU_GET_CUR 0x81
+#define XU_SET_CUR 0x01
+#define XU_CTRL_GET 0xa1
+#define XU_CTRL_SET 0x21
+#define XU_ASIC_SELECTOR 0x01
+#define XU_FLASH_XU6_SELECTOR 0x06
+#define CTRL_TIMEOUT_MS 2000
+#define FLASH_PROBE_ATTEMPTS 3
+#define FLASH_RETRY_DELAY_US 25000
+#define FLASH_MAX_ADDRESS 0x4ffff
+#define SF_XU64_EU_ADDR 0x335
+#define SF_XU64_RW_START_ADDR 0x337
+#define SF_XU64_RW_END_ADDR 0x33b
+
+typedef struct {
+    int vid;
+    int pid;
+    int width;
+    int height;
+    int fps;
+    int expected_altsetting;
+    int forced_payload;
+    const char *kind;
+} mode_profile_t;
+
+typedef struct {
+    uvc_device_t *uvc_device;
+    libusb_device *usb_device;
+    int vid;
+    int pid;
+    int bus;
+    char port[MAX_PORT_PATH];
+    char usb_serial[MAX_TEXT];
+    char device_type[MAX_TEXT];
+    char side[16];
+    char flash_serial[MAX_TEXT];
+    int control_interface;
+    int streaming_interface;
+    int altsetting;
+    unsigned int descriptor_payload;
+    unsigned int negotiated_payload;
+    int mode_ok;
+    int flash_ok;
+    int flash_params_ok;
+    double fx_params[5];
+    double fy_params[5];
+    double fz_params[21];
+    double ft_params[20];
+    double fw_params[9];
+    int opened_ok;
+    char error[MAX_TEXT];
+} camera_candidate_t;
+
+typedef struct {
+    int sightac[2];
+    int decxin;
+    int bus;
+    char outer_path[MAX_PORT_PATH];
+} camera_group_t;
+
+typedef enum {
+    FLASH_MODE_FULL = 0,
+    FLASH_MODE_IDENTITY = 1,
+    FLASH_MODE_NONE = 2,
+    FLASH_MODE_TOPOLOGY_ONLY = 3,
+} flash_mode_t;
+
+static const mode_profile_t *profile_for(int vid, int pid) {
+    static const mode_profile_t sightac = {
+        SIGHTAC_VID, SIGHTAC_PID, 640, 480, 30, 3, 800, "sightac"
+    };
+    /* The scanner reports the camera's *preferred* altsetting -- the one the
+     * descriptor advertises, which gives frames the most room: alt7/1280
+     * (2 transactions per microframe) fits 8 x 32 x 1280 = 327680 B per frame,
+     * while alt6/944 fits only 241664 B against a measured worst case of
+     * 234148 B.
+     *
+     * This value is *reported*, not used as the starting rung. Measured
+     * 2026-09-15: alt7 stalls every 45-130 s while all three cameras stream,
+     * on both host controllers tried, and it delivers the same 30.00 fps as
+     * alt6 -- so the extra per-frame headroom buys nothing and the app starts
+     * at the most conservative pair instead (uvc_camera_service.py,
+     * _starting_mode). Keeping the scanner honest about the descriptor matters
+     * even so: the app checks this pair against the service's mode table, and a
+     * mismatch means scanner and service were built apart from each other. */
+    static const mode_profile_t decxin = {
+        DECXIN_VID, DECXIN_PID, 1280, 960, 30, 7, 1280, "decxin"
+    };
+    if (vid == SIGHTAC_VID && pid == SIGHTAC_PID) {
+        return &sightac;
+    }
+    if (vid == DECXIN_VID && pid == DECXIN_PID) {
+        return &decxin;
+    }
+    return NULL;
+}
+
+static const char *usb_error_text(int result) {
+    return result < 0 ? libusb_strerror((enum libusb_error)result) :
+                        libusb_strerror((enum libusb_error)result);
+}
+
+static void copy_text(char *destination, size_t size, const char *source) {
+    size_t length;
+    if (size == 0) {
+        return;
+    }
+    if (source == NULL) {
+        destination[0] = '\0';
+        return;
+    }
+    length = strlen(source);
+    if (length >= size) {
+        length = size - 1;
+    }
+    memcpy(destination, source, length);
+    destination[length] = '\0';
+}
+
+static void write_json_string(FILE *out, const char *value) {
+    fputc('"', out);
+    for (const unsigned char *cursor = (const unsigned char *)(value ? value : "");
+         *cursor != '\0'; ++cursor) {
+        switch (*cursor) {
+        case '"':
+            fputs("\\\"", out);
+            break;
+        case '\\':
+            fputs("\\\\", out);
+            break;
+        case '\b':
+            fputs("\\b", out);
+            break;
+        case '\f':
+            fputs("\\f", out);
+            break;
+        case '\n':
+            fputs("\\n", out);
+            break;
+        case '\r':
+            fputs("\\r", out);
+            break;
+        case '\t':
+            fputs("\\t", out);
+            break;
+        default:
+            if (*cursor < 0x20) {
+                fprintf(out, "\\u%04x", (unsigned int)*cursor);
+            } else {
+                fputc(*cursor, out);
+            }
+            break;
+        }
+    }
+    fputc('"', out);
+}
+
+static int format_uvc_port_path(uvc_device_t *device, char *out,
+                                size_t out_size) {
+    uint8_t ports[8];
+    int count = uvc_get_port_numbers(device, ports, sizeof(ports));
+    size_t used = 0;
+    if (count < 0 || out_size == 0) {
+        return count < 0 ? count : LIBUSB_ERROR_INVALID_PARAM;
+    }
+    out[0] = '\0';
+    for (int index = 0; index < count; ++index) {
+        int written = snprintf(out + used, out_size - used, "%s%u",
+                               index == 0 ? "" : ".", ports[index]);
+        if (written < 0 || (size_t)written >= out_size - used) {
+            return LIBUSB_ERROR_OVERFLOW;
+        }
+        used += (size_t)written;
+    }
+    return 0;
+}
+
+static int format_libusb_port_path(libusb_device *device, char *out,
+                                   size_t out_size) {
+    uint8_t ports[8];
+    int count = libusb_get_port_numbers(device, ports, sizeof(ports));
+    size_t used = 0;
+    if (count < 0 || out_size == 0) {
+        return count < 0 ? count : LIBUSB_ERROR_INVALID_PARAM;
+    }
+    out[0] = '\0';
+    for (int index = 0; index < count; ++index) {
+        int written = snprintf(out + used, out_size - used, "%s%u",
+                               index == 0 ? "" : ".", ports[index]);
+        if (written < 0 || (size_t)written >= out_size - used) {
+            return LIBUSB_ERROR_OVERFLOW;
+        }
+        used += (size_t)written;
+    }
+    return 0;
+}
+
+static int find_control_interface(libusb_device *device) {
+    struct libusb_config_descriptor *config = NULL;
+    int result = libusb_get_active_config_descriptor(device, &config);
+    if (result != 0) {
+        return result;
+    }
+    int found = LIBUSB_ERROR_NOT_FOUND;
+    for (int i = 0; i < config->bNumInterfaces && found < 0; ++i) {
+        for (int j = 0; j < config->interface[i].num_altsetting; ++j) {
+            const struct libusb_interface_descriptor *alt =
+                &config->interface[i].altsetting[j];
+            if (alt->bInterfaceClass == LIBUSB_CLASS_VIDEO &&
+                alt->bInterfaceSubClass == 1) {
+                found = alt->bInterfaceNumber;
+                break;
+            }
+        }
+    }
+    libusb_free_config_descriptor(config);
+    return found;
+}
+
+static unsigned int endpoint_payload(const struct libusb_endpoint_descriptor *ep) {
+    unsigned int payload = ep->wMaxPacketSize & 0x07ffu;
+    payload *= 1u + ((ep->wMaxPacketSize >> 11) & 0x03u);
+    return payload;
+}
+
+static int find_stream_mode(libusb_device *device, int expected_altsetting,
+                            unsigned int minimum_payload,
+                            int *interface_number, int *altsetting,
+                            unsigned int *payload) {
+    struct libusb_config_descriptor *config = NULL;
+    int result = libusb_get_active_config_descriptor(device, &config);
+    if (result != 0) {
+        return result;
+    }
+    int found = LIBUSB_ERROR_NOT_FOUND;
+    unsigned int selected_payload = 0;
+    int selected_interface = -1;
+    for (int i = 0; i < config->bNumInterfaces; ++i) {
+        for (int j = 0; j < config->interface[i].num_altsetting; ++j) {
+            const struct libusb_interface_descriptor *alt =
+                &config->interface[i].altsetting[j];
+            if (alt->bInterfaceClass != LIBUSB_CLASS_VIDEO ||
+                alt->bInterfaceSubClass != 2) {
+                continue;
+            }
+            if (alt->bAlternateSetting != expected_altsetting) {
+                continue;
+            }
+            for (int k = 0; k < alt->bNumEndpoints; ++k) {
+                const struct libusb_endpoint_descriptor *ep = &alt->endpoint[k];
+                unsigned int transfer_type = ep->bmAttributes &
+                                              LIBUSB_TRANSFER_TYPE_MASK;
+                if ((ep->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) !=
+                        LIBUSB_ENDPOINT_IN ||
+                    (transfer_type != LIBUSB_TRANSFER_TYPE_ISOCHRONOUS &&
+                     transfer_type != LIBUSB_TRANSFER_TYPE_BULK)) {
+                    continue;
+                }
+                unsigned int current_payload = endpoint_payload(ep);
+                if (current_payload >= minimum_payload &&
+                    current_payload > selected_payload) {
+                    selected_payload = current_payload;
+                    selected_interface = alt->bInterfaceNumber;
+                    found = 0;
+                }
+            }
+        }
+    }
+    libusb_free_config_descriptor(config);
+    if (found == 0) {
+        *interface_number = selected_interface;
+        *altsetting = expected_altsetting;
+        *payload = selected_payload;
+    }
+    if (found == 0 && *interface_number < 0) {
+        found = LIBUSB_ERROR_NOT_FOUND;
+    }
+    return found;
+}
+
+static libusb_device *find_raw_device(libusb_device **devices, ssize_t count,
+                                      int vid, int pid, int bus,
+                                      const char *wanted_port) {
+    for (ssize_t index = 0; index < count; ++index) {
+        struct libusb_device_descriptor descriptor;
+        char port[MAX_PORT_PATH];
+        if (libusb_get_device_descriptor(devices[index], &descriptor) != 0 ||
+            descriptor.idVendor != (uint16_t)vid ||
+            descriptor.idProduct != (uint16_t)pid ||
+            (int)libusb_get_bus_number(devices[index]) != bus ||
+            format_libusb_port_path(devices[index], port, sizeof(port)) != 0 ||
+            strcmp(port, wanted_port) != 0) {
+            continue;
+        }
+        return devices[index];
+    }
+    return NULL;
+}
+
+static int xu_control(libusb_device_handle *handle, int interface_number,
+                      uint8_t unit, uint8_t selector, int get,
+                      uint8_t *data, uint16_t size) {
+    uint8_t request_type = get ? XU_CTRL_GET : XU_CTRL_SET;
+    uint8_t request = get ? XU_GET_CUR : XU_SET_CUR;
+    uint16_t value = (uint16_t)selector << 8;
+    uint16_t index = ((uint16_t)unit << 8) | (uint16_t)interface_number;
+    return libusb_control_transfer(handle, request_type, request, value, index,
+                                   data, size, CTRL_TIMEOUT_MS);
+}
+
+static int asic_read(libusb_device_handle *handle, int interface_number,
+                     uint8_t unit, uint16_t address, uint8_t *value) {
+    uint8_t data[4] = {
+        (uint8_t)(address & 0xff), (uint8_t)(address >> 8), 0, 0xff
+    };
+    int result = xu_control(handle, interface_number, unit,
+                            XU_ASIC_SELECTOR, 0, data, sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    data[3] = 0;
+    result = xu_control(handle, interface_number, unit, XU_ASIC_SELECTOR, 1,
+                        data, sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    *value = data[2];
+    return 0;
+}
+
+static int asic_write(libusb_device_handle *handle, int interface_number,
+                      uint8_t unit, uint16_t address, uint8_t value) {
+    uint8_t data[4] = {
+        (uint8_t)(address & 0xff), (uint8_t)(address >> 8), value, 0
+    };
+    int result = xu_control(handle, interface_number, unit,
+                            XU_ASIC_SELECTOR, 0, data, sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    return 0;
+}
+
+static int known_chip(uint8_t chip) {
+    switch (chip) {
+    case 0x15: case 0x16: case 0x22: case 0x23: case 0x25:
+    case 0x32: case 0x33: case 0x56: case 0x70: case 0x71:
+    case 0x75: case 0x76: case 0x83: case 0x85: case 0x86:
+    case 0x87: case 0x88: case 0x89: case 0x90: case 0x92:
+    case 0x98: case 0x99:
+        return 1;
+    default:
+        return 0;
+    }
+}
+
+static int find_xu_unit(libusb_device_handle *handle, int interface_number,
+                        uint8_t *unit) {
+    for (uint8_t candidate = 3; candidate <= 4; ++candidate) {
+        uint8_t raw[4] = {0x1f, 0x10, 0, 0xff};
+        int set_result = xu_control(handle, interface_number, candidate,
+                                    XU_ASIC_SELECTOR, 0, raw, sizeof(raw));
+        int get_result = -1;
+        if (set_result == (int)sizeof(raw)) {
+            raw[3] = 0;
+            get_result = xu_control(handle, interface_number, candidate,
+                                    XU_ASIC_SELECTOR, 1, raw, sizeof(raw));
+        }
+        uint8_t value = get_result == (int)sizeof(raw) ? raw[2] : 0;
+        if (value == 0xaa && get_result == (int)sizeof(raw)) {
+            uint8_t id80f0 = 0;
+            uint8_t id80f1 = 0;
+            uint8_t id80f3 = 0;
+            int r0 = asic_read(handle, interface_number, candidate, 0x80f0,
+                               &id80f0);
+            int r1 = asic_read(handle, interface_number, candidate, 0x80f1,
+                               &id80f1);
+            int r3 = asic_read(handle, interface_number, candidate, 0x80f3,
+                               &id80f3);
+            if (r0 == 0 && r1 == 0 && r3 == 0 &&
+                (known_chip(id80f0) ||
+                 (id80f0 == 0x00 && id80f1 == 0x02 && id80f3 == 0x24) ||
+                 (id80f0 == 0x01 && id80f1 == 0x02 && id80f3 == 0x23) ||
+                 (id80f0 == 0x04 && id80f1 == 0x02 && id80f3 == 0x24))) {
+                value = id80f0;
+            }
+        }
+        if (set_result == (int)sizeof(raw) &&
+            get_result == (int)sizeof(raw) &&
+            (known_chip(value) || value == 0x00 || value == 0x01 ||
+             value == 0x04)) {
+            *unit = candidate;
+            return 0;
+        }
+    }
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int sf_xu6_write_config(libusb_device_handle *handle,
+                               int interface_number, uint8_t unit,
+                               uint32_t start_address, uint32_t data_size,
+                               uint8_t buffer_size) {
+    uint8_t data[64] = {0};
+    data[0] = (uint8_t)(start_address & 0xff);
+    data[1] = (uint8_t)((start_address >> 8) & 0xff);
+    data[2] = (uint8_t)((start_address >> 16) & 0xff);
+    data[3] = (uint8_t)((start_address >> 24) & 0xff);
+    data[4] = 2u << 6;
+    data[5] = buffer_size;
+    uint32_t end_address = start_address + data_size;
+    data[6] = (uint8_t)(end_address & 0xff);
+    data[7] = (uint8_t)((end_address >> 8) & 0xff);
+    data[8] = (uint8_t)((end_address >> 16) & 0xff);
+    data[9] = (uint8_t)((end_address >> 24) & 0xff);
+    data[10] = 0x0b;
+    data[11] = 0x01;
+    int result = xu_control(handle, interface_number, unit,
+                            XU_FLASH_XU6_SELECTOR, 0, data, sizeof(data));
+    return result == (int)sizeof(data) ? 0 :
+           (result < 0 ? result : LIBUSB_ERROR_IO);
+}
+
+static int sf_xu6_stop(libusb_device_handle *handle, int interface_number,
+                       uint8_t unit) {
+    for (uint16_t i = 0; i < 4; ++i) {
+        int result = asic_write(handle, interface_number, unit,
+                                SF_XU64_RW_START_ADDR + i, 0);
+        if (result != 0) {
+            return result;
+        }
+        result = asic_write(handle, interface_number, unit,
+                            SF_XU64_RW_END_ADDR + i, 0);
+        if (result != 0) {
+            return result;
+        }
+    }
+    return asic_write(handle, interface_number, unit, SF_XU64_EU_ADDR, 0);
+}
+
+static int sf_xu6_read_block(libusb_device_handle *handle, int interface_number,
+                             uint8_t unit, uint32_t address, uint8_t *out,
+                             uint8_t length) {
+    if (length == 0 || length > 64 || address > FLASH_MAX_ADDRESS ||
+        address + length < address) {
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+    int result = sf_xu6_stop(handle, interface_number, unit);
+    if (result != 0) {
+        return result;
+    }
+    result = sf_xu6_write_config(handle, interface_number, unit, address,
+                                 length, length);
+    if (result != 0) {
+        return result;
+    }
+    uint8_t data[64] = {0};
+    result = xu_control(handle, interface_number, unit,
+                        XU_FLASH_XU6_SELECTOR, 1, data, sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    memcpy(out, data, length);
+    return 0;
+}
+
+static int sf_xu6_read(libusb_device_handle *handle, int interface_number,
+                       uint8_t unit, uint32_t address, uint8_t *out,
+                       size_t length) {
+    while (length > 0) {
+        uint8_t chunk = length > 64 ? 64 : (uint8_t)length;
+        int result = sf_xu6_read_block(handle, interface_number, unit, address,
+                                       out, chunk);
+        if (result != 0) {
+            return result;
+        }
+        address += chunk;
+        out += chunk;
+        length -= chunk;
+    }
+    return 0;
+}
+
+static int sf_xu6_prepare_290(libusb_device_handle *handle,
+                              int interface_number, uint8_t unit) {
+    int result = asic_write(handle, interface_number, unit, 0x8045, 10);
+    if (result != 0) {
+        return result;
+    }
+    return asic_write(handle, interface_number, unit, 0x8e10, 1);
+}
+
+static void sleep_for_probe(size_t attempt) {
+    useconds_t delay = FLASH_RETRY_DELAY_US *
+                       (useconds_t)(attempt + 1U);
+    usleep(delay);
+}
+
+static void decode_flash_text(const uint8_t *raw, size_t length,
+                              char *out, size_t out_size) {
+    size_t used = 0;
+    if (out_size == 0) {
+        return;
+    }
+    for (size_t i = 0; i < length && used + 1 < out_size; ++i) {
+        if (raw[i] == 0 || raw[i] == 0xff) {
+            break;
+        }
+        out[used++] = isprint(raw[i]) ? (char)raw[i] : '.';
+    }
+    while (used > 0 && isspace((unsigned char)out[used - 1])) {
+        --used;
+    }
+    out[used] = '\0';
+}
+
+static void decode_flash_serial(const uint8_t *raw, size_t length,
+                                char *out, size_t out_size) {
+    size_t used = 0;
+    if (out_size == 0) {
+        return;
+    }
+    /* Sonix parameter-table strings use the same UTF-16LE-like layout as
+     * the vendor SDK: length in bytes at [0], characters at [2], [4]... . */
+    if (length >= 2 && raw[0] >= 2 && raw[0] <= length * 2 &&
+        (raw[0] & 1u) == 0) {
+        size_t chars = (raw[0] - 2) / 2;
+        for (size_t index = 0; index < chars &&
+             2 + index * 2 < length && used + 1 < out_size; ++index) {
+            uint8_t value = raw[2 + index * 2];
+            if (value == 0 || value == 0xff) {
+                break;
+            }
+            out[used++] = isprint(value) ? (char)value : '.';
+        }
+    } else {
+        decode_flash_text(raw, length, out, out_size);
+        return;
+    }
+    while (used > 0 && isspace((unsigned char)out[used - 1])) {
+        --used;
+    }
+    out[used] = '\0';
+}
+
+static void reset_flash_identity(camera_candidate_t *candidate) {
+    memset(candidate->device_type, 0, sizeof(candidate->device_type));
+    memset(candidate->side, 0, sizeof(candidate->side));
+    memset(candidate->flash_serial, 0, sizeof(candidate->flash_serial));
+    memset(candidate->fx_params, 0, sizeof(candidate->fx_params));
+    memset(candidate->fy_params, 0, sizeof(candidate->fy_params));
+    memset(candidate->fz_params, 0, sizeof(candidate->fz_params));
+    memset(candidate->fw_params, 0, sizeof(candidate->fw_params));
+    memset(candidate->ft_params, 0, sizeof(candidate->ft_params));
+    candidate->flash_ok = 0;
+    candidate->flash_params_ok = 0;
+    candidate->error[0] = '\0';
+}
+
+static int read_flash_identity_once(camera_candidate_t *candidate,
+                                    libusb_device_handle *handle,
+                                    int read_calibration) {
+    uint8_t unit = 0;
+    int result = find_xu_unit(handle, candidate->control_interface, &unit);
+    if (result != 0) {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "XU unit: %s", usb_error_text(result));
+        return result;
+    }
+    result = sf_xu6_prepare_290(handle, candidate->control_interface, unit);
+    if (result != 0) {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "XU6 prepare: %s", usb_error_text(result));
+        return result;
+    }
+
+    char params[5][MAX_TEXT];
+    memset(params, 0, sizeof(params));
+    for (size_t index = 0; index < 5; ++index) {
+        uint8_t raw[8] = {0};
+        result = sf_xu6_read(handle, candidate->control_interface, unit,
+                             0x45000 + (uint32_t)(index * sizeof(raw)), raw,
+                             sizeof(raw));
+        if (result != 0) {
+            snprintf(candidate->error, sizeof(candidate->error),
+                     "Flash device_params[%zu]: %s", index,
+                     usb_error_text(result));
+            return result;
+        }
+        decode_flash_text(raw, sizeof(raw), params[index], sizeof(params[index]));
+    }
+    copy_text(candidate->device_type, sizeof(candidate->device_type), params[0]);
+    copy_text(candidate->side, sizeof(candidate->side), params[1]);
+    copy_text(candidate->flash_serial, sizeof(candidate->flash_serial), params[2]);
+    if (!(strcmp(candidate->device_type, "planar") == 0 ||
+          strcmp(candidate->device_type, "curved") == 0 ||
+          strcmp(candidate->device_type, "bevel") == 0)) {
+        char message[MAX_TEXT + 32];
+        snprintf(message, sizeof(message), "Flash device_type is %s",
+                 candidate->device_type[0] ? candidate->device_type : "empty");
+        copy_text(candidate->error, sizeof(candidate->error), message);
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+    uint32_t parameter_start = 0x8000;
+    uint8_t table[0x2b] = {0};
+    int table_result = sf_xu6_read(handle, candidate->control_interface,
+                                   unit, 0x160, table, sizeof(table));
+    if (table_result != 0) {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "Flash parameter_table: %s", usb_error_text(table_result));
+        return table_result;
+    }
+    if (table[0x0f] == 0xff) {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "Flash parameter start address is blank");
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+        parameter_start = ((uint32_t)table[0x0f] << 24) |
+                          ((uint32_t)table[0x10] << 16) |
+                          ((uint32_t)table[0x11] << 8) | table[0x12];
+
+    uint8_t serial_raw[64] = {0};
+    int serial_result = sf_xu6_read(handle, candidate->control_interface,
+                                    unit, parameter_start + 0xc0, serial_raw,
+                                    sizeof(serial_raw));
+    if (serial_result != 0) {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "Flash device_serial: %s", usb_error_text(serial_result));
+        return serial_result;
+    }
+    char flash_serial[MAX_TEXT] = {0};
+    decode_flash_serial(serial_raw, sizeof(serial_raw), flash_serial,
+                        sizeof(flash_serial));
+    if (flash_serial[0] == '\0') {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "Flash device_serial is empty");
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+    copy_text(candidate->flash_serial, sizeof(candidate->flash_serial),
+              flash_serial);
+    for (char *cursor = candidate->side; *cursor != '\0'; ++cursor) {
+        *cursor = (char)tolower((unsigned char)*cursor);
+    }
+    if (strcmp(candidate->side, "left") != 0 &&
+        strcmp(candidate->side, "right") != 0) {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "Flash side is %s", candidate->side[0] ? candidate->side : "empty");
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+    candidate->flash_ok = 1;
+    if (!read_calibration) {
+        return 0;
+    }
+
+    struct {
+        uint32_t address;
+        double *values;
+        size_t count;
+        const char *name;
+    } calibration[] = {
+        {0x41000, candidate->fx_params, 5, "fx"},
+        {0x42000, candidate->fy_params, 5, "fy"},
+        {0x43000, candidate->fz_params, 21, "fz"},
+        {0x47000, candidate->ft_params, 20, "ft"},
+        {0x44000, candidate->fw_params, 9, "fw"},
+    };
+    for (size_t table_index = 0;
+         table_index < sizeof(calibration) / sizeof(calibration[0]);
+         ++table_index) {
+        /* Each XU6 read pays the setup cost of stop/config/control transfers.
+         * Read each contiguous calibration table in 64-byte blocks instead
+         * of issuing one transfer per double. */
+        uint8_t raw[21 * sizeof(double)] = {0};
+        size_t raw_size = calibration[table_index].count * sizeof(double);
+        result = sf_xu6_read(
+            handle, candidate->control_interface, unit,
+            calibration[table_index].address, raw, raw_size);
+        if (result != 0) {
+            snprintf(candidate->error, sizeof(candidate->error),
+                     "Flash %s: %s", calibration[table_index].name,
+                     usb_error_text(result));
+            return result;
+        }
+        for (size_t value_index = 0;
+             value_index < calibration[table_index].count; ++value_index) {
+            const uint8_t *slot = raw + value_index * sizeof(double);
+            int erased = 1;
+            for (size_t byte = 0; byte < sizeof(double); ++byte) {
+                if (slot[byte] != 0xff) erased = 0;
+            }
+            if (erased && (strcmp(calibration[table_index].name, "ft") == 0 ||
+                           (strcmp(calibration[table_index].name, "fz") == 0 && value_index >= 8))) {
+                /* Match 0902 _default_force_calibration_params for erased
+                 * extension slots only. Required coefficients and I/O errors
+                 * remain fail-closed. FT's first/fourth defaults are 1, not 0. */
+                calibration[table_index].values[value_index] =
+                    (strcmp(calibration[table_index].name, "ft") == 0 &&
+                     (value_index == 0 || value_index == 3)) ? 1.0 : 0.0;
+                continue;
+            }
+            memcpy(&calibration[table_index].values[value_index], slot,
+                   sizeof(double));
+            if (!isfinite(calibration[table_index].values[value_index]) &&
+                !(strcmp(calibration[table_index].name, "fw") == 0 &&
+                  value_index >= 5)) {
+                snprintf(candidate->error, sizeof(candidate->error),
+                         "Flash %s[%zu] is not finite",
+                         calibration[table_index].name, value_index);
+                return LIBUSB_ERROR_INVALID_PARAM;
+            }
+        }
+    }
+    candidate->flash_params_ok = 1;
+    candidate->flash_ok = 1;
+    return 0;
+}
+
+static int flash_double_equal(double first, double second) {
+    if (isnan(first) && isnan(second)) {
+        return 1;
+    }
+    return first == second;
+}
+
+static int flash_double_array_equal(const double *first, const double *second,
+                                    size_t count) {
+    for (size_t index = 0; index < count; ++index) {
+        if (!flash_double_equal(first[index], second[index])) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static int flash_readout_equal(const camera_candidate_t *first,
+                               const camera_candidate_t *second,
+                               int compare_calibration) {
+    if (strcmp(first->device_type, second->device_type) != 0 ||
+        strcmp(first->side, second->side) != 0 ||
+        strcmp(first->flash_serial, second->flash_serial) != 0) {
+        return 0;
+    }
+    if (!compare_calibration) {
+        return 1;
+    }
+    return
+           strcmp(first->side, second->side) == 0 &&
+           strcmp(first->flash_serial, second->flash_serial) == 0 &&
+           flash_double_array_equal(first->fx_params, second->fx_params, 5) &&
+           flash_double_array_equal(first->fy_params, second->fy_params, 5) &&
+           flash_double_array_equal(first->fz_params, second->fz_params, 21) &&
+           flash_double_array_equal(first->ft_params, second->ft_params, 20) &&
+           flash_double_array_equal(first->fw_params, second->fw_params, 9);
+}
+
+static int read_flash_identity_verified(camera_candidate_t *candidate,
+                                        libusb_device_handle *handle,
+                                        int read_calibration) {
+    char last_error[MAX_TEXT] = "";
+    int last_result = LIBUSB_ERROR_IO;
+
+    for (int attempt = 0; attempt < FLASH_PROBE_ATTEMPTS; ++attempt) {
+        camera_candidate_t verified;
+        int result;
+
+        reset_flash_identity(candidate);
+        result = read_flash_identity_once(candidate, handle,
+                                          read_calibration);
+        if (result != 0) {
+            copy_text(last_error, sizeof(last_error), candidate->error);
+            last_result = result;
+            if (attempt + 1 < FLASH_PROBE_ATTEMPTS) {
+                sleep_for_probe((size_t)attempt);
+            }
+            continue;
+        }
+
+        /* A single XU6 transfer can complete while its small DMA/control
+         * state was disturbed by USB arbitration.  Read the immutable tables
+         * into an independent structure and require bit-stable identity and
+         * calibration values before accepting them as complete. */
+        memset(&verified, 0, sizeof(verified));
+        verified.control_interface = candidate->control_interface;
+        result = read_flash_identity_once(&verified, handle,
+                                          read_calibration);
+        if (result == 0) {
+            if (flash_readout_equal(candidate, &verified,
+                                    read_calibration)) {
+                return 0;
+            }
+            snprintf(candidate->error, sizeof(candidate->error),
+                     "Flash readback verification mismatch");
+        } else {
+            char message[MAX_TEXT + 40];
+            snprintf(message, sizeof(message),
+                     "Flash readback verification: %s", verified.error);
+            copy_text(candidate->error, sizeof(candidate->error), message);
+        }
+        copy_text(last_error, sizeof(last_error), candidate->error);
+        last_result = result == 0 ? LIBUSB_ERROR_IO : result;
+        if (attempt + 1 < FLASH_PROBE_ATTEMPTS) {
+            sleep_for_probe((size_t)attempt);
+        }
+    }
+
+    candidate->error[0] = '\0';
+    copy_text(candidate->error, sizeof(candidate->error),
+              last_error[0] ? last_error : "Flash probe exhausted retries");
+    candidate->flash_ok = 0;
+    candidate->flash_params_ok = 0;
+    return last_result;
+}
+
+static int inspect_candidate(camera_candidate_t *candidate,
+                             flash_mode_t flash_mode) {
+    const mode_profile_t *profile = profile_for(candidate->vid, candidate->pid);
+    if (candidate->usb_device == NULL) {
+        copy_text(candidate->error, sizeof(candidate->error),
+                  "libusb device disappeared");
+        candidate->mode_ok = 0;
+        return -1;
+    }
+    candidate->control_interface = find_control_interface(candidate->usb_device);
+    if (candidate->control_interface < 0) {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "control interface: %s", usb_error_text(candidate->control_interface));
+        candidate->mode_ok = 0;
+        return -1;
+    }
+    int descriptor_interface = -1;
+    int descriptor_alt = -1;
+    unsigned int descriptor_payload = 0;
+    int descriptor_result = find_stream_mode(
+        candidate->usb_device, profile->expected_altsetting,
+        (unsigned int)profile->forced_payload, &descriptor_interface,
+        &descriptor_alt, &descriptor_payload);
+    if (descriptor_result != 0) {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "stream altsetting: %s", usb_error_text(descriptor_result));
+        candidate->mode_ok = 0;
+        return -1;
+    }
+    candidate->streaming_interface = descriptor_interface;
+    candidate->altsetting = descriptor_alt;
+    candidate->descriptor_payload = descriptor_payload;
+
+    uvc_device_handle_t *uvc_handle = NULL;
+    uvc_error_t uvc_result = uvc_open(candidate->uvc_device, &uvc_handle);
+    if (uvc_result != UVC_SUCCESS || uvc_handle == NULL) {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "uvc_open: %s", uvc_strerror(uvc_result));
+        candidate->mode_ok = -1;
+        return -1;
+    }
+    candidate->opened_ok = 1;
+    libusb_device_handle *usb_handle = uvc_get_libusb_handle(uvc_handle);
+
+    uvc_stream_ctrl_t control;
+    memset(&control, 0, sizeof(control));
+    uvc_result = uvc_get_stream_ctrl_format_size(
+        uvc_handle, &control, UVC_FRAME_FORMAT_MJPEG,
+        profile->width, profile->height, profile->fps);
+    if (uvc_result != UVC_SUCCESS) {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "MJPEG %dx%d@%d: %s", profile->width, profile->height,
+                 profile->fps, uvc_strerror(uvc_result));
+        candidate->mode_ok = 0;
+        uvc_close(uvc_handle);
+        return -1;
+    }
+    candidate->streaming_interface = control.bInterfaceNumber;
+    candidate->negotiated_payload = control.dwMaxPayloadTransferSize;
+    candidate->mode_ok = candidate->altsetting == profile->expected_altsetting;
+    int result = 0;
+    if (!candidate->mode_ok) {
+        snprintf(candidate->error, sizeof(candidate->error),
+                 "alt=%d expected=%d", candidate->altsetting,
+                 profile->expected_altsetting);
+        uvc_close(uvc_handle);
+        return -1;
+    }
+    if ((flash_mode == FLASH_MODE_FULL ||
+         flash_mode == FLASH_MODE_IDENTITY) &&
+        candidate->vid == SIGHTAC_VID &&
+        candidate->pid == SIGHTAC_PID) {
+        result = read_flash_identity_verified(
+            candidate, usb_handle, flash_mode == FLASH_MODE_FULL);
+        if (result != 0) {
+            uvc_close(uvc_handle);
+            return -1;
+        }
+    }
+    uvc_close(uvc_handle);
+    return 0;
+}
+
+static int same_outer_parent(const camera_candidate_t *left,
+                             const camera_candidate_t *right) {
+    char left_parent[MAX_PORT_PATH];
+    char right_parent[MAX_PORT_PATH];
+    const char *left_dot = strrchr(left->port, '.');
+    const char *right_dot = strrchr(right->port, '.');
+    if (left_dot == NULL || right_dot == NULL || left->bus != right->bus) {
+        return 0;
+    }
+    size_t left_size = (size_t)(left_dot - left->port);
+    size_t right_size = (size_t)(right_dot - right->port);
+    if (left_size == 0 || left_size >= sizeof(left_parent) ||
+        right_size == 0 || right_size >= sizeof(right_parent)) {
+        return 0;
+    }
+    memcpy(left_parent, left->port, left_size);
+    left_parent[left_size] = '\0';
+    memcpy(right_parent, right->port, right_size);
+    right_parent[right_size] = '\0';
+    return strcmp(left_parent, right_parent) == 0;
+}
+
+static int port_has_prefix(const char *port, const char *prefix) {
+    size_t prefix_size = strlen(prefix);
+    return strncmp(port, prefix, prefix_size) == 0 &&
+           port[prefix_size] == '.';
+}
+
+static int build_groups(const camera_candidate_t *candidates, size_t count,
+                        camera_group_t *groups, size_t *group_count) {
+    int used[MAX_CANDIDATES] = {0};
+    size_t output_count = 0;
+    for (size_t i = 0; i < count; ++i) {
+        if (candidates[i].vid != SIGHTAC_VID || used[i]) {
+            continue;
+        }
+        int matches[2] = {-1, -1};
+        size_t match_count = 0;
+        for (size_t j = i; j < count; ++j) {
+            if (candidates[j].vid == SIGHTAC_VID &&
+                same_outer_parent(&candidates[i], &candidates[j])) {
+                if (match_count < 2) {
+                    matches[match_count] = (int)j;
+                }
+                ++match_count;
+            }
+        }
+        if (match_count != 2) {
+            fprintf(stderr, "[DISCOVERY] ambiguous Sightac group bus=%d parent of %s: %zu node(s)\n",
+                    candidates[i].bus, candidates[i].port, match_count);
+            continue;
+        }
+        char outer_path[MAX_PORT_PATH];
+        const char *dot = strrchr(candidates[matches[0]].port, '.');
+        size_t outer_size = (size_t)(dot - candidates[matches[0]].port);
+        if (outer_size == 0 || outer_size >= sizeof(outer_path)) {
+            continue;
+        }
+        memcpy(outer_path, candidates[matches[0]].port, outer_size);
+        outer_path[outer_size] = '\0';
+
+        int decxin = -1;
+        size_t decxin_count = 0;
+        for (size_t j = 0; j < count; ++j) {
+            if (candidates[j].vid == DECXIN_VID &&
+                candidates[j].pid == DECXIN_PID &&
+                candidates[j].bus == candidates[i].bus &&
+                port_has_prefix(candidates[j].port, outer_path)) {
+                decxin = (int)j;
+                ++decxin_count;
+            }
+        }
+        if (decxin_count != 1 || output_count >= MAX_GROUPS) {
+            fprintf(stderr, "[DISCOVERY] bus=%d outer=%s DECXIN match count=%zu; group rejected\n",
+                    candidates[i].bus, outer_path, decxin_count);
+            continue;
+        }
+        groups[output_count].sightac[0] = matches[0];
+        groups[output_count].sightac[1] = matches[1];
+        groups[output_count].decxin = decxin;
+        groups[output_count].bus = candidates[i].bus;
+        copy_text(groups[output_count].outer_path,
+                  sizeof(groups[output_count].outer_path), outer_path);
+        used[matches[0]] = 1;
+        used[matches[1]] = 1;
+        used[decxin] = 1;
+        ++output_count;
+    }
+    *group_count = output_count;
+    for (size_t i = 0; i < count; ++i) {
+        if (!used[i]) {
+            fprintf(stderr, "[DISCOVERY] ungrouped %s %04x:%04x bus=%d port=%s\n",
+                    profile_for(candidates[i].vid, candidates[i].pid)->kind,
+                    candidates[i].vid, candidates[i].pid, candidates[i].bus,
+                    candidates[i].port);
+        }
+    }
+    return output_count > 0 ? 0 : -1;
+}
+
+static const camera_candidate_t *candidate_by_side(
+    const camera_candidate_t *candidates, const camera_group_t *group,
+    const char *side) {
+    for (size_t i = 0; i < 2; ++i) {
+        const camera_candidate_t *candidate = &candidates[group->sightac[i]];
+        if (strcmp(candidate->side, side) == 0) {
+            return candidate;
+        }
+    }
+    return NULL;
+}
+
+static int group_sides_ok(const camera_candidate_t *candidates,
+                          const camera_group_t *group,
+                          int require_calibration) {
+    const camera_candidate_t *left = candidate_by_side(candidates, group, "left");
+    const camera_candidate_t *right = candidate_by_side(candidates, group, "right");
+    const camera_candidate_t *decxin = &candidates[group->decxin];
+    return left != NULL && right != NULL && left != right &&
+           candidates[group->sightac[0]].flash_ok &&
+           candidates[group->sightac[1]].flash_ok &&
+           (!require_calibration ||
+            (candidates[group->sightac[0]].flash_params_ok &&
+             candidates[group->sightac[1]].flash_params_ok)) &&
+           left->mode_ok > 0 && right->mode_ok > 0 &&
+           decxin->mode_ok > 0;
+}
+
+static void print_candidate(const camera_candidate_t *candidate,
+                            flash_mode_t flash_mode) {
+    const mode_profile_t *profile = profile_for(candidate->vid, candidate->pid);
+    const char *mode_status = candidate->mode_ok > 0 ? "ok" :
+                              (candidate->mode_ok < 0 ? "unknown" : "failed");
+    fprintf(stderr,
+            "[DISCOVERY] %-7s vidpid=%04x:%04x bus=%d port=%s usb_serial=%s "
+            "control_if=%d stream_if=%d alt=%d descriptor_payload=%u "
+            "negotiated_payload=%u mode=%s",
+            profile->kind, candidate->vid, candidate->pid, candidate->bus,
+            candidate->port, candidate->usb_serial[0] ? candidate->usb_serial : "<none>",
+            candidate->control_interface, candidate->streaming_interface,
+            candidate->altsetting, candidate->descriptor_payload,
+            candidate->negotiated_payload, mode_status);
+    if (candidate->vid == SIGHTAC_VID &&
+        (flash_mode == FLASH_MODE_FULL ||
+         flash_mode == FLASH_MODE_IDENTITY)) {
+        const char *calibration = flash_mode == FLASH_MODE_IDENTITY
+                                      ? "skipped"
+                                      : (candidate->flash_params_ok
+                                             ? "ok" : "failed");
+        fprintf(stderr, " flash=%s calibration=%s side=%s serial=%s type=%s",
+                candidate->flash_ok ? "ok" : "failed",
+                calibration,
+                candidate->side[0] ? candidate->side : "<none>",
+                candidate->flash_serial[0] ? candidate->flash_serial : "<none>",
+                candidate->device_type[0] ? candidate->device_type : "<none>");
+    }
+    if (candidate->error[0]) {
+        fprintf(stderr, " error=%s", candidate->error);
+    }
+    fputc('\n', stderr);
+}
+
+static void write_json_candidate(FILE *out,
+                                 const camera_candidate_t *candidate,
+                                 int include_flash,
+                                 int include_calibration) {
+    const mode_profile_t *profile = profile_for(candidate->vid, candidate->pid);
+    fprintf(out,
+            "{\"kind\":");
+    write_json_string(out, profile->kind);
+    fprintf(out,
+            ",\"vid\":%d,\"pid\":%d,\"bus\":%d,\"port\":",
+            candidate->vid, candidate->pid, candidate->bus);
+    write_json_string(out, candidate->port);
+    fprintf(out,
+            ",\"usb_serial\":");
+    write_json_string(out, candidate->usb_serial);
+    fprintf(out,
+            ",\"control_interface\":%d,\"streaming_interface\":%d,"
+            "\"altsetting\":%d,\"descriptor_payload\":%u,"
+            "\"negotiated_payload\":%u,\"mode_ok\":%s",
+            candidate->control_interface, candidate->streaming_interface,
+            candidate->altsetting, candidate->descriptor_payload,
+            candidate->negotiated_payload,
+            candidate->mode_ok > 0 ? "true" : "false");
+    if (include_flash) {
+        fprintf(out, ",\"flash_ok\":%s,\"flash_params_ok\":%s,\"side\":",
+                candidate->flash_ok ? "true" : "false",
+                candidate->flash_params_ok ? "true" : "false");
+        write_json_string(out, candidate->side);
+        fprintf(out, ",\"flash_serial\":");
+        write_json_string(out, candidate->flash_serial);
+        fprintf(out, ",\"device_type\":");
+        write_json_string(out, candidate->device_type);
+        if (!include_calibration) {
+            goto candidate_error;
+        }
+        fprintf(out, ",\"flash_params\":{\"device_type\":");
+        write_json_string(out, candidate->device_type);
+        fprintf(out, ",\"fx_params\":[");
+        for (size_t i = 0; i < 5; ++i) {
+            if (i != 0) fputc(',', out);
+            fprintf(out, "%.17g", candidate->fx_params[i]);
+        }
+        fprintf(out, "],\"fy_params\":[");
+        for (size_t i = 0; i < 5; ++i) {
+            if (i != 0) fputc(',', out);
+            fprintf(out, "%.17g", candidate->fy_params[i]);
+        }
+        fprintf(out, "],\"fz_params\":[");
+        for (size_t i = 0; i < 21; ++i) {
+            if (i != 0) fputc(',', out);
+            fprintf(out, "%.17g", candidate->fz_params[i]);
+        }
+        fprintf(out, "],\"ft_params\":[");
+        for (size_t i = 0; i < 20; ++i) {
+            if (i != 0) fputc(',', out);
+            fprintf(out, "%.17g", candidate->ft_params[i]);
+        }
+        fprintf(out, "],\"fw_params\":[");
+        for (size_t i = 0; i < 9; ++i) {
+            if (i != 0) fputc(',', out);
+            if (isfinite(candidate->fw_params[i])) {
+                fprintf(out, "%.17g", candidate->fw_params[i]);
+            } else {
+                /* The bevel firmware reserves fw[5..8]; current ROI/line
+                 * code consumes only fw[0..4].  Keep the JSON valid. */
+                fputs("null", out);
+            }
+        }
+        fprintf(out, "],\"flash_state\":\"programmed\","
+                     "\"calibration_source\":\"hardware\"}");
+    }
+candidate_error:
+    fprintf(out, ",\"error\":");
+    write_json_string(out, candidate->error);
+    fputc('}', out);
+}
+
+static void write_camera_section(FILE *out, const camera_candidate_t *candidate,
+                                 int group_number, const char *name,
+                                 const char *socket_name) {
+    const mode_profile_t *profile = profile_for(candidate->vid, candidate->pid);
+    fprintf(out,
+            "[%s]\n"
+            "vid=0x%04x\n"
+            "pid=0x%04x\n"
+            "usb_bus=%d\n"
+            "usb_port_path=%s\n"
+            "streaming_interface=%d\n"
+            "forced_altsetting=%d\n"
+            "forced_payload=%d\n"
+            "width=%d\n"
+            "height=%d\n"
+            "fps=%d\n"
+            "format=MJPEG\n"
+            "socket_path=/tmp/ksq-camera-service-unit-%d-%s.sock\n\n",
+            name, candidate->vid, candidate->pid, candidate->bus, candidate->port,
+            candidate->streaming_interface, candidate->altsetting,
+            profile->forced_payload, profile->width, profile->height,
+            profile->fps, group_number, socket_name);
+}
+
+static int write_generated_config(FILE *out, const camera_candidate_t *candidates,
+                                  const camera_group_t *groups,
+                                  size_t group_count) {
+    for (size_t index = 0; index < group_count; ++index) {
+        if (!group_sides_ok(candidates, &groups[index], 1)) {
+            fprintf(stderr, "[DISCOVERY] group %zu rejected: mode or left/right Flash identity is incomplete\n",
+                    index + 1);
+            return -1;
+        }
+    }
+    fprintf(out,
+            "# Generated by discover-uvc-config.\n"
+            "# Scope: Sightac + DECXIN only; Fays is intentionally excluded.\n"
+            "# Bus/port/interface/alt are from the current libusb/libuvc scan.\n\n");
+    for (size_t index = 0; index < group_count; ++index) {
+        const camera_candidate_t *left =
+            candidate_by_side(candidates, &groups[index], "left");
+        const camera_candidate_t *right =
+            candidate_by_side(candidates, &groups[index], "right");
+        const camera_candidate_t *decxin = &candidates[groups[index].decxin];
+        char name[64];
+        snprintf(name, sizeof(name), "unit_%zu_sightac_left", index + 1);
+        write_camera_section(out, left, (int)(index + 1), name,
+                             "sightac-left");
+        snprintf(name, sizeof(name), "unit_%zu_sightac_right", index + 1);
+        write_camera_section(out, right, (int)(index + 1), name,
+                             "sightac-right");
+        snprintf(name, sizeof(name), "unit_%zu_decxin", index + 1);
+        write_camera_section(out, decxin, (int)(index + 1), name, "decxin");
+    }
+    return 0;
+}
+
+static int write_json_report(FILE *out, const camera_candidate_t *candidates,
+                             const camera_group_t *groups, size_t group_count,
+                             flash_mode_t flash_mode) {
+    const int include_flash = flash_mode == FLASH_MODE_FULL ||
+                              flash_mode == FLASH_MODE_IDENTITY;
+    const int include_calibration = flash_mode == FLASH_MODE_FULL;
+    const int require_calibration = flash_mode == FLASH_MODE_FULL;
+    fprintf(out, "{\"groups\":[");
+    for (size_t index = 0; index < group_count; ++index) {
+        const camera_group_t *group = &groups[index];
+        if (index != 0) {
+            fputc(',', out);
+        }
+        fprintf(out, "{\"bus\":%d,\"outer_path\":", group->bus);
+        write_json_string(out, group->outer_path);
+        fprintf(out, ",\"sightac\":[");
+        write_json_candidate(out, &candidates[group->sightac[0]],
+                             include_flash, include_calibration);
+        fputc(',', out);
+        write_json_candidate(out, &candidates[group->sightac[1]],
+                             include_flash, include_calibration);
+        fprintf(out, "],\"decxin\":");
+        write_json_candidate(out, &candidates[group->decxin], 0, 0);
+        fprintf(out, ",\"valid\":%s}",
+                group_sides_ok(candidates, group,
+                               require_calibration) ? "true" : "false");
+    }
+    fprintf(out, "]}\n");
+    return ferror(out) ? -1 : 0;
+}
+
+static void print_usage(const char *program) {
+    fprintf(stderr,
+            "usage: %s [--emit-config PATH] [--json] [--skip-flash|--identity-only|--topology-only] [--bus N --port-prefix P]\n"
+            "  default: scan Sightac/DECXIN and read Sightac Flash side/serial\n"
+            "  --emit-config PATH: write a generated camera-service INI\n"
+            "  --json: write machine-readable UVC groups to stdout\n"
+            "  --skip-flash: topology/mode report only; never emits a usable INI\n"
+            "  --identity-only: read Flash side/serial without calibration tables\n"
+            "  --topology-only: USB topology only; does not open UVC streams\n"
+            "  --bus N --port-prefix P: inspect only this physical USB group\n",
+            program);
+}
+
+int main(int argc, char **argv) {
+    const char *config_path = NULL;
+    int json_output = 0;
+    flash_mode_t flash_mode = FLASH_MODE_FULL;
+    int only_bus = -1;
+    const char *only_port = NULL;
+    for (int index = 1; index < argc; ++index) {
+        if (strcmp(argv[index], "--emit-config") == 0 && index + 1 < argc) {
+            config_path = argv[++index];
+        } else if (strcmp(argv[index], "--bus") == 0 && index + 1 < argc) {
+            const char *value = argv[++index];
+            if (!*value || strlen(value) > 3 || strspn(value, "0123456789") != strlen(value)) return 2;
+            only_bus = atoi(value);
+            if (only_bus <= 0 || only_bus > 255) return 2;
+        } else if (strcmp(argv[index], "--port-prefix") == 0 && index + 1 < argc) {
+            only_port = argv[++index];
+            if (!*only_port || strspn(only_port, "0123456789.") != strlen(only_port)) return 2;
+        } else if (strcmp(argv[index], "--json") == 0) {
+            json_output = 1;
+        } else if (strcmp(argv[index], "--skip-flash") == 0) {
+            flash_mode = FLASH_MODE_NONE;
+        } else if (strcmp(argv[index], "--identity-only") == 0) {
+            flash_mode = FLASH_MODE_IDENTITY;
+        } else if (strcmp(argv[index], "--topology-only") == 0) {
+            flash_mode = FLASH_MODE_TOPOLOGY_ONLY;
+        } else {
+            print_usage(argv[0]);
+            return 2;
+        }
+    }
+
+    if ((only_bus > 0) != (only_port != NULL)) return 2;
+
+    uvc_context_t *uvc_context = NULL;
+    uvc_error_t uvc_result = uvc_init(&uvc_context, NULL);
+    if (uvc_result != UVC_SUCCESS) {
+        fprintf(stderr, "[DISCOVERY] uvc_init failed: %s\n",
+                uvc_strerror(uvc_result));
+        return 1;
+    }
+    uvc_device_t **devices = NULL;
+    uvc_result = uvc_get_device_list(uvc_context, &devices);
+    if (uvc_result != UVC_SUCCESS) {
+        fprintf(stderr, "[DISCOVERY] uvc_get_device_list failed: %s\n",
+                uvc_strerror(uvc_result));
+        uvc_exit(uvc_context);
+        return 1;
+    }
+    libusb_context *usb_context = NULL;
+    int usb_result = libusb_init(&usb_context);
+    if (usb_result != 0) {
+        fprintf(stderr, "[DISCOVERY] libusb_init failed: %s\n",
+                usb_error_text(usb_result));
+        uvc_free_device_list(devices, 1);
+        uvc_exit(uvc_context);
+        return 1;
+    }
+    libusb_device **raw_devices = NULL;
+    ssize_t raw_count = libusb_get_device_list(usb_context, &raw_devices);
+    if (raw_count < 0) {
+        fprintf(stderr, "[DISCOVERY] libusb_get_device_list failed: %s\n",
+                usb_error_text((int)raw_count));
+        libusb_exit(usb_context);
+        uvc_free_device_list(devices, 1);
+        uvc_exit(uvc_context);
+        return 1;
+    }
+
+    camera_candidate_t candidates[MAX_CANDIDATES];
+    memset(candidates, 0, sizeof(candidates));
+    size_t candidate_count = 0;
+    for (size_t index = 0; devices[index] != NULL; ++index) {
+        /* Filter physical scope BEFORE descriptors/Flash/open operations.
+         * A second rig must never open cameras already streaming for the first. */
+        if (only_port) {
+            char port[MAX_TEXT] = {0};
+            size_t length = strlen(only_port);
+            if ((int)uvc_get_bus_number(devices[index]) != only_bus ||
+                format_uvc_port_path(devices[index], port, sizeof(port)) != 0 ||
+                strncmp(port, only_port, length) != 0 ||
+                (port[length] != '\0' && port[length] != '.')) continue;
+        }
+        uvc_device_descriptor_t *descriptor = NULL;
+        if (uvc_get_device_descriptor(devices[index], &descriptor) != UVC_SUCCESS ||
+            descriptor == NULL) {
+            continue;
+        }
+        const mode_profile_t *profile =
+            profile_for(descriptor->idVendor, descriptor->idProduct);
+        if (profile == NULL || candidate_count >= MAX_CANDIDATES) {
+            uvc_free_device_descriptor(descriptor);
+            continue;
+        }
+        camera_candidate_t *candidate = &candidates[candidate_count++];
+        candidate->uvc_device = devices[index];
+        candidate->control_interface = -1;
+        candidate->streaming_interface = -1;
+        candidate->altsetting = -1;
+        candidate->mode_ok = -1;
+        candidate->vid = descriptor->idVendor;
+        candidate->pid = descriptor->idProduct;
+        copy_text(candidate->usb_serial, sizeof(candidate->usb_serial),
+                  descriptor->serialNumber);
+        if (format_uvc_port_path(devices[index], candidate->port,
+                                 sizeof(candidate->port)) != 0) {
+            copy_text(candidate->error, sizeof(candidate->error),
+                      "cannot read USB port path");
+        }
+        candidate->bus = uvc_get_bus_number(devices[index]);
+        candidate->usb_device = find_raw_device(
+            raw_devices, raw_count, candidate->vid, candidate->pid,
+            candidate->bus, candidate->port);
+        int status = 0;
+        if (flash_mode != FLASH_MODE_TOPOLOGY_ONLY) {
+            status = inspect_candidate(candidate, flash_mode);
+        }
+        if (status != 0 && candidate->error[0] == '\0') {
+            copy_text(candidate->error, sizeof(candidate->error), "inspection failed");
+        }
+        print_candidate(candidate, flash_mode);
+        uvc_free_device_descriptor(descriptor);
+    }
+
+    camera_group_t groups[MAX_GROUPS];
+    memset(groups, 0, sizeof(groups));
+    size_t group_count = 0;
+    if (candidate_count == 0 ||
+        build_groups(candidates, candidate_count, groups, &group_count) != 0) {
+        fprintf(stderr, "[DISCOVERY] no complete Sightac + DECXIN topology group\n");
+        libusb_free_device_list(raw_devices, 1);
+        libusb_exit(usb_context);
+        uvc_free_device_list(devices, 1);
+        uvc_exit(uvc_context);
+        return 3;
+    }
+    fprintf(stderr, "[DISCOVERY] complete group(s)=%zu\n", group_count);
+
+    int result = 0;
+    if (config_path != NULL && json_output) {
+        fprintf(stderr, "[DISCOVERY] refusing --emit-config with --json\n");
+        result = 2;
+    } else if (json_output) {
+        if (write_json_report(stdout, candidates, groups, group_count,
+                              flash_mode) != 0) {
+            result = 1;
+        }
+    } else if (config_path != NULL) {
+        if (flash_mode != FLASH_MODE_FULL) {
+            fprintf(stderr, "[DISCOVERY] refusing --emit-config without full Flash mode\n");
+            result = 2;
+        } else {
+            char temporary_path[PATH_MAX];
+            int path_result = snprintf(temporary_path, sizeof(temporary_path),
+                                       "%s.tmp.%ld", config_path,
+                                       (long)getpid());
+            if (path_result < 0 || (size_t)path_result >= sizeof(temporary_path)) {
+                fprintf(stderr, "[DISCOVERY] config path is too long: %s\n",
+                        config_path);
+                result = 1;
+                goto cleanup;
+            }
+            FILE *out = fopen(temporary_path, "w");
+            if (out == NULL) {
+                fprintf(stderr, "[DISCOVERY] cannot write %s: %s\n",
+                        config_path, strerror(errno));
+                result = 1;
+            } else {
+                int write_result = write_generated_config(
+                    out, candidates, groups, group_count);
+                int close_result = fclose(out);
+                if (write_result != 0 || close_result != 0 ||
+                    rename(temporary_path, config_path) != 0) {
+                    fprintf(stderr, "[DISCOVERY] failed to generate %s\n",
+                            config_path);
+                    unlink(temporary_path);
+                    result = 1;
+                } else {
+                    fprintf(stderr, "[DISCOVERY] generated config: %s\n",
+                            config_path);
+                }
+            }
+        }
+    } else if (flash_mode == FLASH_MODE_FULL) {
+        if (write_generated_config(stdout, candidates, groups, group_count) != 0) {
+            result = 1;
+        }
+    }
+cleanup:
+    libusb_free_device_list(raw_devices, 1);
+    libusb_exit(usb_context);
+    uvc_free_device_list(devices, 1);
+    uvc_exit(uvc_context);
+    return result;
+}

collector/core/gripper/camera_service_src/tools/sonix_flash_probe.c

@@ -0,0 +1,618 @@
+/*
+ * Read-only Sonix XU/Serial-Flash probe.
+ *
+ * This is the libusb equivalent of the source SDK's
+ * UVCIOC_CTRL_QUERY(UVC_SET_CUR/UVC_GET_CUR) path.  It never issues a
+ * serial-flash write or erase command.  The SET_CUR requests below only set
+ * the address for the following read, exactly as XU_ReadDataFormFlash().
+ */
+#include <libusb-1.0/libusb.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define SONIX_VID 0x0c45
+#define SONIX_PID 0x636f
+#define XU_GET_CUR 0x81
+#define XU_SET_CUR 0x01
+#define XU_CTRL_GET 0xa1
+#define XU_CTRL_SET 0x21
+#define XU_ASIC_SELECTOR 0x01
+#define XU_FLASH_SELECTOR 0x03
+#define XU_FLASH_XU6_SELECTOR 0x06
+#define CTRL_TIMEOUT_MS 2000
+#define FLASH_MAX_ADDRESS 0x4ffff
+#define SF_XU64_EU_ADDR 0x335
+#define SF_XU64_RW_START_ADDR 0x337
+#define SF_XU64_RW_END_ADDR 0x33b
+
+static void print_hex(const uint8_t *data, size_t length) {
+    for (size_t i = 0; i < length; ++i) {
+        printf("%02x%s", data[i], (i + 1 == length) ? "" : " ");
+    }
+}
+
+static void print_ascii(const uint8_t *data, size_t length) {
+    putchar('"');
+    for (size_t i = 0; i < length; ++i) {
+        putchar(isprint(data[i]) ? (int)data[i] : '.');
+    }
+    puts("\"");
+}
+
+static int port_path(libusb_device *device, char *out, size_t out_size) {
+    uint8_t ports[8];
+    int count = libusb_get_port_numbers(device, ports, sizeof(ports));
+    size_t used = 0;
+    if (count < 0) {
+        return count;
+    }
+    out[0] = '\0';
+    for (int i = 0; i < count; ++i) {
+        int written = snprintf(out + used, out_size - used, "%s%u",
+                               i == 0 ? "" : ".", ports[i]);
+        if (written < 0 || (size_t)written >= out_size - used) {
+            return LIBUSB_ERROR_OVERFLOW;
+        }
+        used += (size_t)written;
+    }
+    return 0;
+}
+
+static int control_interface(libusb_device *device) {
+    struct libusb_config_descriptor *config = NULL;
+    int result = libusb_get_active_config_descriptor(device, &config);
+    if (result != 0) {
+        return result;
+    }
+    int found = LIBUSB_ERROR_NOT_FOUND;
+    for (int i = 0; i < config->bNumInterfaces && found < 0; ++i) {
+        for (int j = 0; j < config->interface[i].num_altsetting; ++j) {
+            const struct libusb_interface_descriptor *alt =
+                &config->interface[i].altsetting[j];
+            if (alt->bInterfaceClass == LIBUSB_CLASS_VIDEO &&
+                alt->bInterfaceSubClass == 1) {
+                found = alt->bInterfaceNumber;
+                break;
+            }
+        }
+    }
+    libusb_free_config_descriptor(config);
+    return found;
+}
+
+static int xu_control(libusb_device_handle *handle, int interface_number,
+                      uint8_t unit, uint8_t selector, int get,
+                      uint8_t *data, uint16_t size) {
+    uint8_t request_type = get ? XU_CTRL_GET : XU_CTRL_SET;
+    uint8_t request = get ? XU_GET_CUR : XU_SET_CUR;
+    uint16_t value = (uint16_t)selector << 8;
+    uint16_t index = ((uint16_t)unit << 8) | (uint16_t)interface_number;
+    return libusb_control_transfer(handle, request_type, request, value, index,
+                                   data, size, CTRL_TIMEOUT_MS);
+}
+
+static int asic_read(libusb_device_handle *handle, int interface_number,
+                     uint8_t unit, uint16_t address, uint8_t *value) {
+    uint8_t data[4] = {
+        (uint8_t)(address & 0xff), (uint8_t)(address >> 8), 0, 0xff
+    };
+    int result = xu_control(handle, interface_number, unit, XU_ASIC_SELECTOR,
+                            0, data, sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    data[3] = 0;
+    result = xu_control(handle, interface_number, unit, XU_ASIC_SELECTOR,
+                        1, data, sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    *value = data[2];
+    return 0;
+}
+
+static int asic_write(libusb_device_handle *handle, int interface_number,
+                      uint8_t unit, uint16_t address, uint8_t value) {
+    uint8_t data[4] = {
+        (uint8_t)(address & 0xff), (uint8_t)(address >> 8), value, 0
+    };
+    int result = xu_control(handle, interface_number, unit, XU_ASIC_SELECTOR,
+                            0, data, sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    return 0;
+}
+
+static int sf_xu6_write_config(libusb_device_handle *handle,
+                               int interface_number, uint8_t unit,
+                               uint32_t start_address, uint32_t data_size,
+                               uint8_t buffer_size) {
+    /* This is the packed XU6Data structure used by SetReadInfo_SFXU6(). */
+    uint8_t data[64] = {0};
+    data[0] = (uint8_t)(start_address & 0xff);
+    data[1] = (uint8_t)((start_address >> 8) & 0xff);
+    data[2] = (uint8_t)((start_address >> 16) & 0xff);
+    data[3] = (uint8_t)((start_address >> 24) & 0xff);
+    data[4] = 2u << 6; /* dummy write */
+    data[5] = buffer_size;
+    uint32_t end_address = start_address + data_size;
+    data[6] = (uint8_t)(end_address & 0xff);
+    data[7] = (uint8_t)((end_address >> 8) & 0xff);
+    data[8] = (uint8_t)((end_address >> 16) & 0xff);
+    data[9] = (uint8_t)((end_address >> 24) & 0xff);
+    data[10] = 0x0b; /* SDK default read command */
+    data[11] = 0x01; /* SF output mode */
+    int result = xu_control(handle, interface_number, unit,
+                            XU_FLASH_XU6_SELECTOR, 0, data, sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    return 0;
+}
+
+static int sf_xu6_stop(libusb_device_handle *handle, int interface_number,
+                       uint8_t unit) {
+    int result;
+    for (uint16_t i = 0; i < 4; ++i) {
+        result = asic_write(handle, interface_number, unit,
+                            SF_XU64_RW_START_ADDR + i, 0);
+        if (result != 0) {
+            return result;
+        }
+        result = asic_write(handle, interface_number, unit,
+                            SF_XU64_RW_END_ADDR + i, 0);
+        if (result != 0) {
+            return result;
+        }
+    }
+    return asic_write(handle, interface_number, unit, SF_XU64_EU_ADDR, 0);
+}
+
+static int sf_xu6_read_block(libusb_device_handle *handle, int interface_number,
+                             uint8_t unit, uint32_t address, uint8_t *out,
+                             uint8_t length) {
+    if (length == 0 || length > 64 || address > FLASH_MAX_ADDRESS ||
+        address + length < address) {
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+    int result = sf_xu6_stop(handle, interface_number, unit);
+    if (result != 0) {
+        return result;
+    }
+    result = sf_xu6_write_config(handle, interface_number, unit, address,
+                                 length, length);
+    if (result != 0) {
+        return result;
+    }
+    uint8_t data[64] = {0};
+    result = xu_control(handle, interface_number, unit,
+                        XU_FLASH_XU6_SELECTOR, 1, data, sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    memcpy(out, data, length);
+    return 0;
+}
+
+static int sf_xu6_read(libusb_device_handle *handle, int interface_number,
+                       uint8_t unit, uint32_t address, uint8_t *out,
+                       size_t length) {
+    while (length > 0) {
+        uint8_t chunk = length > 64 ? 64 : (uint8_t)length;
+        int result = sf_xu6_read_block(handle, interface_number, unit, address,
+                                       out, chunk);
+        if (result != 0) {
+            return result;
+        }
+        address += chunk;
+        out += chunk;
+        length -= chunk;
+    }
+    return 0;
+}
+
+static int sf_xu6_prepare_290(libusb_device_handle *handle,
+                              int interface_number, uint8_t unit) {
+    /* SetSFControllerSCK() for ROM290 in the vendor source. */
+    int result = asic_write(handle, interface_number, unit, 0x8045, 10);
+    if (result != 0) {
+        return result;
+    }
+    return asic_write(handle, interface_number, unit, 0x8e10, 1);
+}
+
+static int known_chip(uint8_t chip) {
+    switch (chip) {
+    case 0x15: case 0x16: case 0x22: case 0x23: case 0x25:
+    case 0x32: case 0x33: case 0x56: case 0x70: case 0x71:
+    case 0x75: case 0x76: case 0x83: case 0x85: case 0x86:
+    case 0x87: case 0x88: case 0x89: case 0x90: case 0x92:
+    case 0x98: case 0x99:
+        return 1;
+    default:
+        return 0;
+    }
+}
+
+static int find_xu_unit(libusb_device_handle *handle, int interface_number,
+                        uint8_t *unit, uint8_t *chip) {
+    /* The vendor source deliberately probes units 3 and 4 in this order. */
+    for (uint8_t candidate = 3; candidate <= 4; ++candidate) {
+        uint8_t value = 0;
+        uint8_t raw[4] = {
+            0x1f, 0x10, 0, 0xff
+        };
+        int set_result = xu_control(handle, interface_number, candidate,
+                                    XU_ASIC_SELECTOR, 0, raw, sizeof(raw));
+        int get_result = -1;
+        if (set_result == (int)sizeof(raw)) {
+            raw[3] = 0;
+            get_result = xu_control(handle, interface_number, candidate,
+                                    XU_ASIC_SELECTOR, 1, raw, sizeof(raw));
+            if (get_result == (int)sizeof(raw)) {
+                value = raw[2];
+            }
+        }
+        fprintf(stderr, "  xu_probe unit=%u set=%d get=%d data=",
+                candidate, set_result, get_result);
+        print_hex(raw, sizeof(raw));
+        fputc('\n', stderr);
+        if (value == 0xaa && get_result == (int)sizeof(raw)) {
+            uint8_t id80f0 = 0, id80f1 = 0, id80f3 = 0;
+            int r0 = asic_read(handle, interface_number, candidate, 0x80f0,
+                               &id80f0);
+            int r1 = asic_read(handle, interface_number, candidate, 0x80f1,
+                               &id80f1);
+            int r3 = asic_read(handle, interface_number, candidate, 0x80f3,
+                               &id80f3);
+            fprintf(stderr, "  xu_probe fallback 80f0=%02x(%d) 80f1=%02x(%d) "
+                            "80f3=%02x(%d)\n",
+                    id80f0, r0, id80f1, r1, id80f3, r3);
+            if (r0 == 0 && r1 == 0 && r3 == 0 &&
+                (known_chip(id80f0) ||
+                 (id80f0 == 0x00 && id80f1 == 0x02 && id80f3 == 0x24) ||
+                 (id80f0 == 0x01 && id80f1 == 0x02 && id80f3 == 0x23) ||
+                 (id80f0 == 0x04 && id80f1 == 0x02 && id80f3 == 0x24))) {
+                value = id80f0;
+            }
+        }
+        if (set_result == (int)sizeof(raw) &&
+            get_result == (int)sizeof(raw) &&
+            (known_chip(value) || value == 0x00 || value == 0x01 ||
+             value == 0x04)) {
+            *unit = candidate;
+            *chip = value;
+            return 0;
+        }
+    }
+    return LIBUSB_ERROR_NOT_FOUND;
+}
+
+static int flash_read_block(libusb_device_handle *handle, int interface_number,
+                            uint8_t unit, uint32_t address, uint8_t *out,
+                            uint8_t length) {
+    if (length == 0 || length > 8 || address > FLASH_MAX_ADDRESS) {
+        return LIBUSB_ERROR_INVALID_PARAM;
+    }
+    uint8_t data[11] = {0};
+    data[0] = (uint8_t)address;
+    data[1] = (uint8_t)(address >> 8);
+    uint8_t command = address < 0x10000 ? 0x88 :
+                      address < 0x20000 ? 0x98 :
+                      address < 0x30000 ? 0xa8 : 0xb8;
+    data[2] = (uint8_t)((command & 0xf0) | length);
+    int result = xu_control(handle, interface_number, unit,
+                            XU_FLASH_SELECTOR, 0, data, sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    result = xu_control(handle, interface_number, unit, XU_FLASH_SELECTOR, 1,
+                        data, sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    memcpy(out, data + 3, length);
+    return 0;
+}
+
+static int flash_read(libusb_device_handle *handle, int interface_number,
+                      uint8_t unit, uint32_t address, uint8_t *out,
+                      size_t length) {
+    while (length > 0) {
+        uint8_t chunk = length > 8 ? 8 : (uint8_t)length;
+        int result = flash_read_block(handle, interface_number, unit, address,
+                                      out, chunk);
+        if (result != 0) {
+            return result;
+        }
+        address += chunk;
+        out += chunk;
+        length -= chunk;
+    }
+    return 0;
+}
+
+static int rom_read(libusb_device_handle *handle, int interface_number,
+                    uint8_t unit, uint16_t address, uint8_t *out) {
+    uint8_t data[11] = {0};
+    data[0] = (uint8_t)address;
+    data[1] = (uint8_t)(address >> 8);
+    data[2] = 8;
+    int result = xu_control(handle, interface_number, unit, 0x04, 0, data,
+                            sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    result = xu_control(handle, interface_number, unit, 0x04, 1, data,
+                        sizeof(data));
+    if (result != (int)sizeof(data)) {
+        return result < 0 ? result : LIBUSB_ERROR_IO;
+    }
+    memcpy(out, data + 3, 8);
+    return 0;
+}
+
+static int looks_like_rom(const uint8_t *data) {
+    return isdigit(data[0]) && isdigit(data[1]) && isdigit(data[2]) &&
+           data[3] == 'R' && data[4] == '0';
+}
+
+static void print_setting(const char *label, const uint8_t *data, size_t size) {
+    printf("  %s raw=", label);
+    print_hex(data, size);
+    printf(" ascii=");
+    print_ascii(data, size);
+    if (data[0] >= 2 && (data[0] & 1) == 0 && data[0] <= size * 2) {
+        size_t chars = (data[0] - 2) / 2;
+        printf("  %s decoded=\"", label);
+        for (size_t i = 0; i < chars; ++i) {
+            putchar(isprint(data[2 + i * 2]) ? data[2 + i * 2] : '.');
+        }
+        puts("\"");
+    }
+}
+
+typedef int (*flash_reader_fn)(libusb_device_handle *, int, uint8_t,
+                               uint32_t, uint8_t *, size_t);
+
+static void print_double_group(libusb_device_handle *handle, int interface_number,
+                               uint8_t unit, const char *label,
+                               uint32_t address, size_t count,
+                               flash_reader_fn reader) {
+    printf("  %s @0x%05x:", label, address);
+    for (size_t i = 0; i < count; ++i) {
+        uint8_t raw[8] = {0};
+        int result = reader(handle, interface_number, unit,
+                            address + (uint32_t)(i * sizeof(raw)), raw,
+                            sizeof(raw));
+        if (result != 0) {
+            printf(" [%zu]=<read:%s>", i, libusb_strerror(result));
+            continue;
+        }
+        if (memcmp(raw, "\xff\xff\xff\xff\xff\xff\xff\xff", 8) == 0) {
+            printf(" [%zu]=<unburned>", i);
+            continue;
+        }
+        double value = 0.0;
+        memcpy(&value, raw, sizeof(value));
+        if (isfinite(value)) {
+            printf(" [%zu]=%.12g", i, value);
+        } else {
+            printf(" [%zu]=<nonfinite>", i);
+        }
+    }
+    putchar('\n');
+}
+
+static void print_device_params(libusb_device_handle *handle,
+                                int interface_number, uint8_t unit,
+                                flash_reader_fn reader) {
+    printf("  device_params @0x45000:");
+    for (size_t i = 0; i < 5; ++i) {
+        uint8_t raw[8] = {0};
+        int result = reader(handle, interface_number, unit,
+                            0x45000 + (uint32_t)(i * sizeof(raw)), raw,
+                            sizeof(raw));
+        if (result != 0) {
+            printf(" [%zu]=<read:%s>", i, libusb_strerror(result));
+            continue;
+        }
+        char text[9];
+        memcpy(text, raw, sizeof(raw));
+        text[8] = '\0';
+        for (size_t j = 0; j < sizeof(raw); ++j) {
+            if (text[j] == '\0' || text[j] == (char)0xff) {
+                text[j] = '\0';
+                break;
+            }
+            if (!isprint((unsigned char)text[j])) {
+                text[j] = '.';
+            }
+        }
+        printf(" [%zu]=%s", i, text[0] == '\0' ? "<empty>" : text);
+    }
+    putchar('\n');
+}
+
+static int probe_device(libusb_device *device, const char *wanted_port) {
+    struct libusb_device_descriptor descriptor;
+    char port[64];
+    if (libusb_get_device_descriptor(device, &descriptor) != 0 ||
+        descriptor.idVendor != SONIX_VID || descriptor.idProduct != SONIX_PID ||
+        port_path(device, port, sizeof(port)) != 0 ||
+        (wanted_port != NULL && strcmp(port, wanted_port) != 0)) {
+        return 0;
+    }
+
+    libusb_device_handle *handle = NULL;
+    int result = libusb_open(device, &handle);
+    if (result != 0) {
+        fprintf(stderr, "port=%s open failed: %s\n", port,
+                libusb_strerror(result));
+        return -1;
+    }
+    int interface_number = control_interface(device);
+    if (interface_number < 0) {
+        fprintf(stderr, "port=%s control interface lookup failed: %s\n", port,
+                libusb_strerror(interface_number));
+        libusb_close(handle);
+        return -1;
+    }
+
+    int was_attached = libusb_kernel_driver_active(handle, interface_number);
+    if (was_attached == 1) {
+        result = libusb_detach_kernel_driver(handle, interface_number);
+        if (result != 0) {
+            fprintf(stderr, "port=%s detach interface=%d failed: %s\n", port,
+                    interface_number, libusb_strerror(result));
+            libusb_close(handle);
+            return -1;
+        }
+    }
+    result = libusb_claim_interface(handle, interface_number);
+    if (result != 0) {
+        fprintf(stderr, "port=%s claim interface=%d failed: %s\n", port,
+                interface_number, libusb_strerror(result));
+        if (was_attached == 1) {
+            libusb_attach_kernel_driver(handle, interface_number);
+        }
+        libusb_close(handle);
+        return -1;
+    }
+
+    uint8_t unit = 0, chip = 0;
+    result = find_xu_unit(handle, interface_number, &unit, &chip);
+    printf("port=%s interface=%d xu_unit=%s", port, interface_number,
+           result == 0 ? "found" : "not-found");
+    if (result == 0) {
+        printf("(%u) chip=0x%02x\n", unit, chip);
+        uint8_t roms[6][8];
+        const uint16_t addresses[6] = {
+            0x9ff8, 0xd2b2, 0xdff8, 0xbff8, 0xc7f8, 0xaff8
+        };
+        int rom_found = 0;
+        for (size_t i = 0; i < 6; ++i) {
+            memset(roms[i], 0xff, sizeof(roms[i]));
+            int read_result = rom_read(handle, interface_number, unit,
+                                       addresses[i], roms[i]);
+            if (read_result == 0) {
+                printf("  ROM[0x%04x]=", addresses[i]);
+                print_hex(roms[i], sizeof(roms[i]));
+                printf(" ascii=");
+                print_ascii(roms[i], sizeof(roms[i]));
+                if (looks_like_rom(roms[i])) {
+                    rom_found = 1;
+                }
+            } else {
+                printf("  ROM[0x%04x] read failed: %s\n", addresses[i],
+                       libusb_strerror(read_result));
+            }
+        }
+
+        uint8_t raw[64];
+        if (flash_read(handle, interface_number, unit, 0, raw, sizeof(raw)) == 0) {
+            printf("  FLASH[0x0000..0x003f]=");
+            print_hex(raw, sizeof(raw));
+            putchar('\n');
+        }
+
+        /* The source SDK's default table fallback is 0x8000. */
+        uint32_t parameter_start = 0x8000;
+        uint8_t rom[8] = {0};
+        for (size_t i = 0; i < 6; ++i) {
+            if (looks_like_rom(roms[i])) {
+                memcpy(rom, roms[i], sizeof(rom));
+                break;
+            }
+        }
+        if (memcmp(rom, "232R0", 4) == 0 && rom[5] == 1) {
+            parameter_start = 0xc000;
+        } else if (memcmp(rom, "232R0", 4) == 0 && rom[5] == 2) {
+            parameter_start = 0xc000;
+        } else if (memcmp(rom, "276R0", 4) == 0 && rom[5] == 1) {
+            parameter_start = 0xc000;
+        } else if (memcmp(rom, "216R0", 4) == 0) {
+            parameter_start = 0x5800;
+        } else if (rom[0] >= '2' && rom[0] <= '9') {
+            /* Newer Sonix layouts store the table address in sectorTable. */
+            uint8_t table[0x2b];
+            if (flash_read(handle, interface_number, unit, 0x160, table,
+                           sizeof(table)) == 0 && table[0x0f] != 0xff) {
+                parameter_start = ((uint32_t)table[0x0f] << 24) |
+                                  ((uint32_t)table[0x10] << 16) |
+                                  ((uint32_t)table[0x11] << 8) | table[0x12];
+            }
+        }
+        printf("  parameter_table_start=0x%08x (rom_probe=%s)\n",
+               parameter_start, rom_found ? "matched" : "unknown");
+        uint8_t setting[64];
+        if (flash_read(handle, interface_number, unit, parameter_start + 0xc0,
+                       setting, sizeof(setting)) == 0) {
+            print_setting("serial", setting, sizeof(setting));
+        } else {
+            printf("  serial read failed at 0x%08x\n",
+                   parameter_start + 0xc0);
+        }
+        int xu6_prepare = sf_xu6_prepare_290(handle, interface_number, unit);
+        printf("  XU6 calibration channel prepare=%s\n",
+               xu6_prepare == 0 ? "ok" : libusb_strerror(xu6_prepare));
+        if (xu6_prepare == 0) {
+            print_double_group(handle, interface_number, unit, "fx_params",
+                               0x41000, 5, sf_xu6_read);
+            print_double_group(handle, interface_number, unit, "fy_params",
+                               0x42000, 5, sf_xu6_read);
+            print_double_group(handle, interface_number, unit, "fz_params",
+                               0x43000, 8, sf_xu6_read);
+            print_double_group(handle, interface_number, unit, "fw_params",
+                               0x44000, 9, sf_xu6_read);
+            print_device_params(handle, interface_number, unit, sf_xu6_read);
+        }
+    } else {
+        printf("\n");
+    }
+
+    libusb_release_interface(handle, interface_number);
+    if (was_attached == 1) {
+        libusb_attach_kernel_driver(handle, interface_number);
+    }
+    libusb_close(handle);
+    return 1;
+}
+
+int main(int argc, char **argv) {
+    const char *wanted_port = argc > 1 ? argv[1] : NULL;
+    libusb_context *context = NULL;
+    int result = libusb_init(&context);
+    if (result != 0) {
+        fprintf(stderr, "libusb_init failed: %s\n", libusb_strerror(result));
+        return 1;
+    }
+    libusb_device **devices = NULL;
+    ssize_t count = libusb_get_device_list(context, &devices);
+    if (count < 0) {
+        fprintf(stderr, "get device list failed: %s\n", libusb_strerror((int)count));
+        libusb_exit(context);
+        return 1;
+    }
+    int matched = 0;
+    for (ssize_t i = 0; i < count; ++i) {
+        int status = probe_device(devices[i], wanted_port);
+        if (status > 0) {
+            matched++;
+        }
+    }
+    libusb_free_device_list(devices, 1);
+    libusb_exit(context);
+    if (wanted_port != NULL && matched == 0) {
+        fprintf(stderr, "no Sonix 0c45:636f device at port %s\n", wanted_port);
+        return 2;
+    }
+    return matched > 0 ? 0 : 2;
+}

collector/core/gripper/devices/gripper_serial.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import re
 import threading
 import time
 from typing import Callable, Optional
@@ -21,7 +22,9 @@ class GripperSerial:
     CONNECT_BAUD = 115200
     CONNECT_TIMEOUT = 0.5
     CONNECT_WRITE_TIMEOUT = 0.5
-    CONNECT_BOOT_DELAY = 2.0
+    # 握手不再固定白等 2 秒：在最长 CONNECT_BOOT_TIMEOUT 内反复发 ``?``，
+    # 收到 STATE 立刻返回。刚上电的 ESP32 仍在窗口内，已就绪的不必空等。
+    CONNECT_BOOT_TIMEOUT = 2.0
     CONNECT_ATTEMPTS = 8
     CONNECT_RETRY_DELAY = 0.3
     COMMAND_TIMEOUT = 1.0
@@ -65,21 +68,28 @@ class GripperSerial:
             return self._last_error
 
     def connect(self, port: str, baud: int = CONNECT_BAUD) -> bool:
-        """打开串口并用原有的八次 ``?`` 握手确认主控在线。"""
+        """独占打开串口，在有限窗口内用 ``?`` 握手确认主控在线。"""
         with self._io_lock:
             self._disconnect_locked()
             self._last_error = None
             try:
+                # 独占模式：串口被其他进程占用时立刻失败，而不是两个进程
+                # 各自读走半条响应，把「被占用」伪装成「握手超时」。
                 opened = self._serial_factory(
                     port,
                     baud,
                     timeout=self.CONNECT_TIMEOUT,
                     write_timeout=self.CONNECT_WRITE_TIMEOUT,
+                    exclusive=True,
                 )
                 self._serial = opened
-                self._sleep(self.CONNECT_BOOT_DELAY)
                 opened.reset_input_buffer()
+                deadline = self._clock() + self.CONNECT_BOOT_TIMEOUT
+                attempts_made = 0
                 for attempt in range(self.CONNECT_ATTEMPTS):
+                    if attempt and self._clock() >= deadline:
+                        break
+                    attempts_made = attempt + 1
                     opened.write(b"?\r\n")
                     line = opened.readline().decode(
                         errors="ignore").strip()
@@ -89,16 +99,18 @@ class GripperSerial:
                     )
                     if line.startswith("STATE"):
                         return True
-                    self._sleep(self.CONNECT_RETRY_DELAY)
+                    if self._clock() < deadline:
+                        self._sleep(self.CONNECT_RETRY_DELAY)
             except Exception as exc:
                 self._last_error = (
                     f"serial open/handshake failed: {exc}"
                 )
                 self._disconnect_locked()
                 return False
+            # 报实际尝试次数，不报上限：被抢占/占用时上限是误导
             self._last_error = (
                 "serial handshake timeout after "
-                f"{self.CONNECT_ATTEMPTS} attempts"
+                f"{attempts_made} attempts"
             )
             self._disconnect_locked()
             return False
@@ -135,6 +147,30 @@ class GripperSerial:
             # 关闭失败时也不能把已经失效的句柄重新暴露给调用方。
             pass
 
+    def query_fays_serial(self) -> str:
+        """读取 ESP32 NVS 中绑定的 Fays 产品序列号；未绑定/无效返回空串。"""
+        response = self.send("QF")
+        prefix = "FAYS_SERIAL:"
+        if not response.startswith(prefix):
+            return ""
+        return response[len(prefix):].strip()
+
+    def set_fays_serial(self, serial: str) -> bool:
+        """写入并持久化 ESP32 绑定的 Fays 产品序列号。"""
+        value = str(serial or "").strip()
+        if (
+            not value
+            or len(value) > 64
+            or re.fullmatch(r"[A-Za-z0-9._-]+", value) is None
+        ):
+            raise ValueError("Fays 序列号只能是 1-64 位字母、数字、点、下划线或短横线")
+        response = self.send(f"WF:{value}")
+        if response.startswith("OK FAYS_SERIAL_SET:"):
+            return True
+        if response.startswith("ERR "):
+            raise RuntimeError(f"ESP32 写入 Fays 序列号失败: {response}")
+        raise RuntimeError(f"ESP32 写入 Fays 序列号无有效响应: {response or '<empty>'}")
+
     def send(self, command: str) -> str:
         """发送一条文本命令并返回匹配的完整响应行。"""
         with self._io_lock:
@@ -149,16 +185,32 @@ class GripperSerial:
                 except Exception:
                     pass
                 opened.write((str(command) + "\r\n").encode())
-                expected = {
-                    "?": ("STATE",),
-                    "G": ("AS5048A", "AS5048A ERR"),
-                    "C": ("OK CONNECT", "ERR"),
-                    "I": ("OK INIT", "ERR"),
-                    "F": ("OK READY", "ERR"),
-                    "E": ("OK ERROR", "ERR"),
-                    "R": ("OK ASR", "AS5048A ERR"),
-                    "S": ("OK START", "ERR"),
-                }.get(str(command)[:1], ())
+                command_text = str(command)
+                if command_text.startswith("WF:"):
+                    # 写绑定：三种终态都算「本条命令的响应」，其余行继续等，
+                    # 免得把固件周期性的 STATE 当成写入结果。
+                    expected = (
+                        "OK FAYS_SERIAL_SET:",
+                        "ERR FAYS_SERIAL_INVALID",
+                        "ERR FAYS_SERIAL_SAVE",
+                    )
+                else:
+                    table = {
+                        "QF": ("FAYS_SERIAL:", "ERR FAYS_SERIAL_NOT_SET"),
+                        "?": ("STATE",),
+                        "G": ("AS5048A", "AS5048A ERR"),
+                        "C": ("OK CONNECT", "ERR"),
+                        "I": ("OK INIT", "ERR"),
+                        "F": ("OK READY", "ERR"),
+                        "E": ("OK ERROR", "ERR"),
+                        "R": ("OK ASR", "AS5048A ERR"),
+                        "S": ("OK START", "ERR"),
+                    }
+                    # 先按完整命令查（QF 是两字符命令），再退回首字符。
+                    # 只按 [:1] 查会让 "QF" 这条永远命中不到，等于宣布
+                    # 「第一行就是响应」——固件周期性的 STATE 会顶替真响应。
+                    expected = table.get(command_text, table.get(
+                        command_text[:1], ()))
                 deadline = self._clock() + self.COMMAND_TIMEOUT
                 last_line = ""
                 while self._clock() < deadline:

collector/core/gripper/devices/uvc_camera_service.py

@@ -25,6 +25,7 @@ import sys
 import cv2
 
 from core.gripper.fays_runtime import PROJECT_ROOT
+from core.gripper.paths import CAMERA_MODE_STATE_DIR
 from core.gripper.runtime.device_access import device_access_guard
 
 # camera_service/python is a checkout-local transport module, not an ambient
@@ -68,12 +69,23 @@ _LIBUVC_DIR = Path(
     PROJECT_ROOT, "camera_service", "build", "third_party", "libuvc")
 
 
-def _native_env():
+def _native_env(binary=None):
+    """只给这个子进程用交付目录里的 libuvc，绝不动主进程的环境。
+
+    ``binary`` 自带 ``third_party/libuvc`` 时优先用它（KSQ_UVC_*_BINARY
+    被指向别处的构建树时仍然自洽），再兜底交付目录内的副本。
+    """
     env = dict(os.environ)
-    existing = env.get("LD_LIBRARY_PATH", "")
-    if _LIBUVC_DIR.is_dir() and str(_LIBUVC_DIR) not in existing:
-        env["LD_LIBRARY_PATH"] = (
-            str(_LIBUVC_DIR) + (f":{existing}" if existing else ""))
+    directories = []
+    if binary is not None:
+        directories.append(
+            str(Path(binary).resolve().parent / "third_party" / "libuvc"))
+    directories.append(str(_LIBUVC_DIR))
+    directories.extend(
+        part for part in env.get("LD_LIBRARY_PATH", "").split(os.pathsep)
+        if part
+    )
+    env["LD_LIBRARY_PATH"] = os.pathsep.join(dict.fromkeys(directories))
     return env
 
 
@@ -81,11 +93,87 @@ class UvcCameraServiceError(RuntimeError):
     """The live libusb/libuvc camera set cannot be used."""
 
 
-def _root_port(physical_path):
-    text = str(physical_path or "").strip()
-    if "-" not in text:
+# 每个机型允许的档位对（altsetting, payload），按从好到差排列，必须与服务端
+# camera_service.c 的档位表逐项一致。服务认不出的档位对会直接 rc=2 退出，
+# 把整个夹爪一起带走，所以这里必须先挡一道，把「配置写错」变成一条看得懂的
+# 报错，而不是一个哑掉的服务进程。
+_MODE_LADDERS = {
+    (0x0C45, 0x636F): ((3, 800),),
+    (0x1BCF, 0x2D4F): ((7, 1280), (6, 944)),
+}
+
+# 起始档位一律取档位表里最保守的那一档（＝表的最后一档），不认控制器。
+#
+# 曾经这里有一张「已知扛不住的控制器 → 起始档位」的表（0000:74:00.4 → alt6）。
+# 2026-09-15 实测把它推翻了：alt7 停摆不是某块控制器的毛病，0000:0a:00.0 上
+# 整机三路一起出流时一样在 78 秒内停摆（两次独立运行、共 3 次停摆，全落在
+# 68~116 秒）。当初判它「总线 1 没事」是拿一次根本没真的跑在 alt7 上的运行
+# 当基准——那时 ini 里的 forced_* 还是死的，服务只是把 ini 的值原样打进了
+# 日志。控制器不是变量，就没必要按机器写死。
+
+
+def _usb_controller_for_bus(bus):
+    """这台相机所在 USB 控制器的 PCI 路径，例如 ``0000:0a:00.0``。
+
+    ``/sys/bus/usb/devices/usbN`` 是指向根 Hub 的符号链接，解开的上一级就是
+    控制器；用 PCI 路径而不是总线号，因为总线号会随插口变。
+
+    它只进落盘键，不参与「选哪一档」的判断——**控制器是不是变量并没有定论**
+    （2026-09-15 实测 alt7 在 74:00.4 与 0a:00.0 上都停摆，但机制没查清），所
+    以不拿它做任何决策。键里带上它只是取保守：学到的东西严格绑在「学它的那条
+    物理路径」上，换机器/换口自然是新键。代价为零——新键没有记忆值，就退回档
+    位表里最保守的那一档，那本来就是我们要的默认。取不到返回空串，调用方退化
+    成「不区分控制器」，功能不受影响。
+    """
+    link = Path(f"/sys/bus/usb/devices/usb{int(bus)}")
+    try:
+        return link.resolve(strict=True).parent.name
+    except (OSError, ValueError):
         return ""
-    return text.split("-", 1)[1].split(".", 1)[0]
+
+
+def _mode_state_key(vid, pid, controller, serial):
+    """「这台相机 × 这条物理路径」的落盘键，规则必须与 C 侧 ``mode_state_key``
+    逐字一致：只保留 ``[A-Za-z0-9-]``，其余一律换成 ``_``。"""
+    raw = (
+        f"{int(vid):04x}_{int(pid):04x}_"
+        f"{controller or 'unknown'}_{serial or 'noserial'}"
+    )
+    return "".join(
+        char if (char.isascii() and (char.isalnum() or char == "-")) else "_"
+        for char in raw
+    )
+
+
+def _pair_is_known(vid, pid, pair):
+    return pair in _MODE_LADDERS.get((int(vid), int(pid)), ())
+
+
+def _read_learned_mode(state_dir, vid, pid, controller, serial):
+    """读服务上一轮学到的档位。文件坏了 / 越界了一律当没学到。"""
+    if not state_dir:
+        return None
+    path = Path(state_dir) / (
+        _mode_state_key(vid, pid, controller, serial) + ".mode"
+    )
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+    values = {}
+    for line in text.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        try:
+            values[key.strip()] = int(value.strip())
+        except ValueError:
+            return None
+    pair = (values.get("altsetting"), values.get("payload"))
+    if not _pair_is_known(vid, pid, pair):
+        return None
+    return pair
 
 
 def _path_contains(bus, outer_path, child_path):
@@ -323,7 +411,17 @@ class UvcCameraServiceManager:
         self._lock = threading.RLock()
         self._services = {}
 
-    def _run_discovery(self, *, usb_bus=None, port_prefix=None):
+    def _run_discovery(self, *, usb_bus=None, port_prefix=None,
+                       skip_flash=False, identity_only=False,
+                       topology_only=False):
+        """Run the live libusb/libuvc discovery pass.
+
+        Three depths, mutually exclusive: ``topology_only`` (enumeration
+        only), ``identity_only`` (also opens UVC control, verifies mode and
+        reads Flash side/serial, skipping the five calibration tables) and
+        the default full read.  ``skip_flash`` is the diagnostic alias for
+        the first two.  Only the full mode can emit a usable config.
+        """
         if not self._discovery_binary.is_file():
             raise UvcCameraServiceError(
                 f"libusb/libuvc 发现程序不存在: {self._discovery_binary}"
@@ -332,16 +430,27 @@ class UvcCameraServiceManager:
             raise UvcCameraServiceError(
                 f"libusb/libuvc 发现程序不可执行: {self._discovery_binary}"
             )
+        if sum(bool(flag) for flag in (
+                skip_flash, identity_only, topology_only)) > 1:
+            raise UvcCameraServiceError(
+                "discover-uvc-config 的扫描深度参数互斥，只能选一个"
+            )
         command = [str(self._discovery_binary), "--json"]
         if usb_bus is not None and port_prefix is not None:
             command += ["--bus", str(usb_bus), "--port-prefix", str(port_prefix)]
+        if topology_only:
+            command.append("--topology-only")
+        elif identity_only:
+            command.append("--identity-only")
+        elif skip_flash:
+            command.append("--skip-flash")
         completed = subprocess.run(
             command,
             capture_output=True,
             text=True,
             timeout=DISCOVERY_TIMEOUT_S,
             check=False,
-            env=_native_env(),
+            env=_native_env(self._discovery_binary),
         )
         if completed.returncode != 0:
             details = "\n".join(
@@ -368,25 +477,27 @@ class UvcCameraServiceManager:
     def _assignment_identity(assignment):
         if not isinstance(assignment, dict):
             raise UvcCameraServiceError(
-                "Fays 尚未完成 device_setup 身份分配"
+                "Fays 尚未完成身份分配"
             )
         esp = assignment.get("esp32") or {}
         fays = assignment.get("fays") or {}
         esp_serial = str(esp.get("serial") or "").strip()
         fays_serial = str(fays.get("product_serial") or "").strip()
-        fays_path = str(
-            fays.get("physical_usb_path") or ""
-        ).strip()
-        if not esp_serial or not fays_serial or not fays_path:
+        if not esp_serial or not fays_serial:
             raise UvcCameraServiceError(
-                "Fays 当前分配缺少 ESP32 serial、Fays serial 或物理路径"
+                "Fays 当前分配缺少 ESP32 serial 或 Fays serial"
             )
-        return esp_serial, fays_serial, fays_path
+        return esp_serial, fays_serial
 
     def _associate_group(self, group, assignment, live_esp):
-        esp_serial, fays_serial, fays_path = self._assignment_identity(
-            assignment
-        )
+        """UVC 组只按 ESP32 serial + bus/outer_path 关联。
+
+        Fays 归属由 ESP32 NVS 里的绑定序列号决定（见 SingleFaysLease），
+        这里不再比较 Fays 的 USB 根端口：Fays 是 USB3/FT602，插在 USB3 口
+        时走 5000M 伴生总线，与触觉/RGB 的 480M 总线 bus 号不同；多控制器
+        机器上两套 rig 还常落在同号根端口，按端口关联只会互相误配。
+        """
+        esp_serial, fays_serial = self._assignment_identity(assignment)
         bus = int(group.get("bus", -1))
         outer_path = str(group.get("outer_path") or "").strip()
         matching_esp = [
@@ -401,15 +512,6 @@ class UvcCameraServiceManager:
                 f"serial={esp_serial} matches={len(matching_esp)} "
                 f"group={bus}-{outer_path}"
             )
-        # Fays is USB3/FT602 and may be reported on a different libusb bus;
-        # the existing topology rule intentionally correlates its root port.
-        if _root_port(fays_path) != str(outer_path).split(".", 1)[0].split(
-            "-", 1
-        )[-1]:
-            raise UvcCameraServiceError(
-                "当前 UVC 组与已分配 Fays 不在同一根端口: "
-                f"fays={fays_path} group={bus}-{outer_path}"
-            )
         normalized = {
             "bus": bus,
             "outer_path": outer_path,
@@ -453,7 +555,7 @@ class UvcCameraServiceManager:
 
     def _discovery_scope(self, assignment, live_esp=None):
         from core.gripper.fays_runtime import discover_esp32_devices
-        serial, _, _ = self._assignment_identity(assignment)
+        serial, _ = self._assignment_identity(assignment)
         devices = tuple(discover_esp32_devices()) if live_esp is None else live_esp
         matches = [d for d in devices if str(d.get("serial", "")).strip() == serial]
         if len(matches) != 1:
@@ -479,7 +581,7 @@ class UvcCameraServiceManager:
             except UvcCameraServiceError:
                 continue
         if len(matches) != 1:
-            esp_serial, fays_serial, _ = self._assignment_identity(assignment)
+            esp_serial, fays_serial = self._assignment_identity(assignment)
             raise UvcCameraServiceError(
                 "当前设备清单身份与动态 UVC 拓扑无法唯一配对: "
                 f"esp32={esp_serial} fays={fays_serial} "
@@ -493,6 +595,10 @@ class UvcCameraServiceManager:
             (
                 int(record["bus"]),
                 record["outer_path"],
+                # ini 里那一行 `usb_controller=` 就是它，而它参与落盘键，所以
+                # 「这份配置长什么样」含控制器：换控制器必须重写 ini，不能复用
+                # 上一个进程。
+                _usb_controller_for_bus(record["bus"]),
                 tuple(sorted(
                     (side, str(candidate["port"]))
                     for side, candidate in record["sightac"].items()
@@ -502,6 +608,44 @@ class UvcCameraServiceManager:
             for record in records
         ))
 
+    @staticmethod
+    def _starting_mode(candidate, controller):
+        """这台相机从哪一档开始。
+
+        优先级：上一轮学到的 > 档位表里最保守的那一档 > 扫描程序报的首选档。
+
+        为什么默认不是首选档：实测 DECXIN 的 alt7（10.24 MB/s）在整机三路一起
+        出流时每 68~116 秒必停摆一次，alt6（7.552 MB/s）同样三路下 30.00 fps
+        长跑不停，而两档出帧率一模一样——首选档多出来的那点每帧余量（327680
+        对 241664 字节）不值一次停摆，用户要的「稳定帧数」也不允许开机就故意
+        赔一次。要那点余量就把 ini 里 forced_altsetting 改回 alt7：真撑不住
+        时服务停两次后会自己退回 alt6 并把结论落盘，下次开机直接用（见
+        camera_service.c 的 maybe_downgrade_altsetting）。学到的值就在这里读
+        回来。"""
+        vid = int(candidate["vid"])
+        pid = int(candidate["pid"])
+        preferred = (int(candidate["altsetting"]),
+                     int(candidate["descriptor_payload"]))
+        if not _pair_is_known(vid, pid, preferred):
+            # 服务对认不出的档位对是 rc=2 直接退出，整个夹爪一起挂。先查
+            # 一遍扫描程序的输出：扫描程序与服务端档位表脱节（比如只装了新
+            # 扫描程序、没重编服务）必须报出来，不能被下面的记忆值盖过去。
+            raise UvcCameraServiceError(
+                f"扫描程序报出服务端不认识的档位 {vid:04x}:{pid:04x} "
+                f"alt={preferred[0]} payload={preferred[1]}；"
+                "扫描程序与服务端档位表已经脱节，需要一起重编"
+            )
+        serial = str(candidate.get("usb_serial") or "").strip()
+        learned = _read_learned_mode(
+            CAMERA_MODE_STATE_DIR, vid, pid, controller, serial
+        )
+        if learned is not None:
+            return learned, "learned"
+        ladder = _MODE_LADDERS[(vid, pid)]
+        if ladder[-1] != preferred:
+            return ladder[-1], "conservative"
+        return preferred, "preferred"
+
     def _write_config(self, records):
         runtime_dir = Path(tempfile.mkdtemp(prefix="ksq-camera-service-"))
         lines = [
@@ -511,12 +655,14 @@ class UvcCameraServiceManager:
         ]
         sockets = {}
         for index, record in enumerate(records, 1):
+            controller = _usb_controller_for_bus(record["bus"])
             for role in ("left", "right", "decxin"):
                 candidate = (
                     record["sightac"][role]
                     if role in {"left", "right"}
                     else record["decxin"]
                 )
+                mode, mode_source = self._starting_mode(candidate, controller)
                 name = f"unit_{index}_{role}"
                 socket_path = runtime_dir / f"{name}.sock"
                 sockets[(index, role)] = str(socket_path)
@@ -527,9 +673,22 @@ class UvcCameraServiceManager:
                     f"usb_bus={int(record['bus'])}",
                     f"usb_port_path={candidate['port']}",
                     f"streaming_interface={int(candidate['streaming_interface'])}",
-                    f"forced_altsetting={int(candidate['altsetting'])}",
-                    "forced_payload=800" if role in {"left", "right"}
-                    else "forced_payload=1280",
+                    # altsetting 和 payload 是一个整体（alt7 的端点就是
+                    # 1280 B/包），必须成对来自同一处：要么都是扫描程序实测的
+                    # 端点描述符，要么都是服务上一轮学到的结论。拆开配会得到
+                    # 一个自相矛盾的档位——2026-09-15 主程序连不上夹爪就是这
+                    # 么来的（alt 取自扫描程序、payload 却是硬编码）。
+                    #
+                    # 这两项现在是**生效的**：服务打开设备后会把它们交给
+                    # libuvc 的 uvc_set_altsetting_override()。在此之前它们
+                    # 只是校验和日志，真正决定档位的是 libuvc 的编译期表，
+                    # 所以「改 ini」曾经完全不改变行为。
+                    f"forced_altsetting={mode[0]}",
+                    f"forced_payload={mode[1]}",
+                    f"# 起始档位来源: {mode_source}",
+                    f"usb_serial={str(candidate.get('usb_serial') or '').strip()}",
+                    f"usb_controller={controller}",
+                    f"state_dir={CAMERA_MODE_STATE_DIR}",
                     "width=640" if role in {"left", "right"}
                     else "width=1280",
                     "height=480" if role in {"left", "right"}
@@ -575,7 +734,7 @@ class UvcCameraServiceManager:
                     stdout=subprocess.DEVNULL,
                     stderr=service_log,
                     start_new_session=True,
-                    env=_native_env(),
+                    env=_native_env(self._service_binary),
                 )
             finally:
                 service_log.close()

collector/core/gripper/fays_serial_probe.py

@@ -87,9 +87,14 @@ def probe_product_serial(
     probe_binary: Optional[str] = None,
     timeout: float = 60.0,
     environment: Optional[Mapping[str, str]] = None,
+    serial_only_fast: bool = False,
 ) -> str:
     """Run the official calibration probe and return ``device.serial``.
 
+    ``serial_only_fast`` 只允许用于身份扫描：探针读一次 SDK 设备信息、停掉
+    自己持有的 IMU 流后直接退出进程，跳过厂商 SDK 较慢的 handle 析构。标定
+    与运行路径必须走完整生命周期，不得使用该参数。
+
     timeout 同时是 SDK 全局初始化锁的等待上限与子进程运行上限：双夹爪
     并发打开时，第二台的探针要等第一台 SLAM 初始化（最长 45s）释放锁，
     20s 会在等待期间误报超时，故放宽到 60s。
@@ -113,15 +118,31 @@ def probe_product_serial(
             # and the device_setup manifest below.
             with device_access_guard(FAYS_SDK_INITIALIZATION_LOCK, timeout=timeout), \
                     fays_device_guard(ports["stereo_dev_port"]):
+                command = [executable]
+                if serial_only_fast:
+                    command.append("--serial-only-fast")
+                command.append(config_path)
                 completed = subprocess.run(
-                    [executable, config_path], capture_output=True, text=True,
+                    command, capture_output=True, text=True,
                     timeout=timeout,
                     env=dict(os.environ if environment is None else environment),
                     check=False,
                 )
         except subprocess.TimeoutExpired as exc:
+            # TimeoutExpired 在 text=True 下也可能带着 bytes。超时发生在
+            # SDK 释放阶段时，前半段（身份/序列号）往往已经成功，把子进程
+            # 最后 20 行留下来，别让一句「超时」把底层证据丢掉。
+            def _text(value):
+                return (
+                    value.decode("utf-8", errors="replace")
+                    if isinstance(value, bytes) else (value or "")
+                )
+            diagnostic = "\n".join(
+                (_text(exc.stdout) + "\n" + _text(exc.stderr)).splitlines()[-20:]
+            )
             raise RuntimeError(
-                f"Fays 标定探测超时: {ports} ({exc.timeout}s)"
+                f"Fays 标定探测超时（含 SDK 资源释放）: {ports} "
+                f"({exc.timeout}s)\n{diagnostic}"
             ) from exc
         output = (
             (completed.stdout or "") + "\n" + (completed.stderr or "")

collector/core/gripper/fays_single.py

@@ -1,16 +1,21 @@
 """单夹爪场景的 Fays S80M 租约（无 device_setup 清单版本）。
 
 主程序一次只服务一套夹爪 rig，设备身份全部来自运行时探测：
-    1. ESP32 串口（VID/PID + USB serial）唯一匹配；
-    2. discover_fays_device_groups() 发现且仅发现一台完整 S80M；
-    3. USB 链路速度 >= FAYS_MIN_USB_SPEED_MBPS，否则拒绝（提示换 USB3 口）；
-    4. probe_product_serial() 通过官方 SDK 探针读取真实产品序列号；
-    5. 按序列号定位 fays_config/fays_vikit_{serial}.yaml 与
+    1. ESP32 按 USB serial 唯一匹配（不看 /dev/ttyACMN 编号）；
+    2. 从该 ESP32 的 NVS 读它绑定的 Fays 产品序列号（串口命令 QF）；
+    3. 枚举在线完整 S80M，先逐台做 USB SuperSpeed 预检，再用官方 SDK 的
+       serial-only-fast 读出真实产品序列号（FT602 描述符和枚举顺序都不算
+       身份）；
+    4. 绑定的序列号必须唯一命中一台在线 Fays —— **不按根端口猜归属**；
+       被其他会话占用的 Fays 不参与匹配，但要写进错误文案；
+    5. 对选中的那台再走一次完整 SDK 生命周期，复核序列号与 ESP32 绑定值
+       一致（Connect 路径的完整校验）；
+    6. 按序列号定位 fays_config/fays_vikit_{serial}.yaml 与
        dist/fays_opencv48/s80m_{serial}_stereo_inertial.yaml；缺任一个就**现场
        用厂商导出程序从这只夹爪读出厂标定补齐**（见 calibration.py），不必再
        人工跑上位机 device_setup + 导入；
-    6. flock 租约 /tmp/ksq-gripper-fays-locks/{serial}.lock 防多开；
-    7. materialize 当前端口的运行时 SDK yaml，并在 /dev/shm 建 IPC 目录。
+    7. flock 租约 /tmp/ksq-gripper-fays-locks/{serial}.lock 防多开；
+    8. materialize 当前端口的运行时 SDK yaml，并在 /dev/shm 建 IPC 目录。
 
 返回的 selected 字典携带 SlamProcessController 与相机服务组合所需字段
 （ports/runtime_config/ipc_dir/trajectory/settings/executable/...）。
@@ -29,6 +34,7 @@ import time
 
 from config import settings
 from core.gripper import calibration, paths
+from core.gripper.devices.gripper_serial import GripperSerial
 from core.gripper.fays_runtime import (
     FAYS_MIN_USB_SPEED_MBPS,
     build_fays_probe_env,
@@ -37,8 +43,10 @@ from core.gripper.fays_runtime import (
     discover_fays_device_groups,
     materialize_fays_device_config,
     validate_fays_sdk_access,
+    validate_fays_superspeed,
 )
 from core.gripper.fays_serial_probe import probe_product_serial
+from core.gripper.runtime.device_access import fays_device_guard
 
 _INSTANCE_IPC_FILES = (
     "orb_pose.json.tmp", "orb_pose.json", "orb_meta.json",
@@ -138,11 +146,15 @@ class SingleFaysLease:
             )
 
     def _match_esp(self, esp_serial):
-        """按 USB serial 唯一匹配 ESP32 控制板，返回其 tty 设备路径。"""
+        """按 USB serial 唯一匹配 ESP32 控制板，返回其设备信息。"""
+        wanted = str(esp_serial or "").strip()
+        if not wanted:
+            raise GripperFaysError(
+                "未提供 ESP32 USB serial，拒绝按端口号或枚举顺序猜测控制板")
         devices = discover_esp32_devices()
         matches = [
             info for info in devices
-            if str(info.get("serial") or "").strip() == str(esp_serial).strip()
+            if str(info.get("serial") or "").strip() == wanted
         ]
         if len(matches) != 1:
             available = ", ".join(
@@ -150,68 +162,154 @@ class SingleFaysLease:
             )
             raise GripperFaysError(
                 "ESP32 控制板未唯一匹配: 期望 serial={} 当前=[{}]".format(
-                    esp_serial, available)
+                    wanted, available)
             )
         return matches[0]
 
-    def _discover_unique_fays_group(self, esp):
-        """按 ESP 的根端口关联 rig 内的 S80M，要求唯一命中。
-
-        Fays 是 USB3/FT602：插在 USB3 口时走 5000M 伴生总线，与 ESP/
-        触觉相机的 480M 总线 bus 号不同（如 ESP=7-2、Fays=8-2 是同一
-        物理口的双总线伴生），因此原程序的拓扑规则只按根端口关联
-        （见 uvc_camera_service._associate_group 的同名注释）。
-        同一台机器可能还插着主程序自己的独立 S80M（不同根端口），
-        必须按夹爪 rig 的拓扑范围区分，不能全机枚举；多台命中即报错
-        不猜归属。rig 内仍只允许 1 台完整 S80M。
-        多控制器机器（双夹爪）还必须带控制器身份比较：两套 rig 可能
-        都插在各自控制器的同号根端口上（实测都是根端口 2，控制器
-        0000:0a:00.0 与 0000:74:00.4），只比端口号会互相误配。
+    def _query_esp_bound_fays_serial(self, esp):
+        """读 ESP32 NVS 里绑定的 Fays 产品序列号（串口命令 ``QF``）。
+
+        串口是独占资源：查询完立刻归还，随后运行时的桥接还要独占打开。
+        未绑定、空值、ERR 一律失败关闭 —— 不允许回退到拓扑猜测。
         """
-        esp_controller, esp_root = self._bus_root(
-            str(esp.get("physical_usb_path") or ""))
-        if not esp_controller or not esp_root:
+        device = str(esp.get("device") or "").strip()
+        esp_serial = str(esp.get("serial") or "<unknown>").strip()
+        if not device:
             raise GripperFaysError(
-                "ESP32 物理 USB 路径无效: {!r}".format(
-                    esp.get("physical_usb_path")))
-        groups = tuple(discover_fays_device_groups())
-        same_rig = [
-            group for group in groups
-            if self._bus_root(group["physical_usb_path"])
-            == (esp_controller, esp_root)
-        ]
-        if len(same_rig) != 1:
-            found = ", ".join(
-                str(g["physical_usb_path"]) for g in same_rig)
+                "ESP32 {} 缺少串口节点，无法查询绑定的 Fays 序列号".format(
+                    esp_serial))
+        bridge = GripperSerial(logger=self._logger)
+        if not bridge.connect(device):
             raise GripperFaysError(
-                "夹爪 rig（控制器 {} 根端口 {}）内发现 {} 台 Fays S80M，"
-                "只允许 1 台: [{}]".format(
-                    esp_controller, esp_root, len(same_rig), found))
-        return same_rig[0]
+                "ESP32 {} 串口连接失败，无法查询绑定的 Fays 序列号: {}".format(
+                    esp_serial, bridge.last_error or "unknown error"))
+        try:
+            response = ""
+            for attempt in range(3):
+                response = bridge.send("QF")
+                if response.startswith(("FAYS_SERIAL:", "ERR FAYS_SERIAL")):
+                    break
+                if response.startswith("STATE") and attempt < 2:
+                    # 固件周期性状态行插在命令响应前面：重试，别把串口
+                    # 收发竞态误判成「没有绑定」。
+                    time.sleep(0.05)
+                    continue
+                break
+        finally:
+            bridge.disconnect()
+        prefix = "FAYS_SERIAL:"
+        if response.startswith(prefix):
+            serial = response[len(prefix):].strip()
+            if serial:
+                return serial
+        if response.startswith("ERR FAYS_SERIAL_NOT_SET"):
+            raise GripperFaysError(
+                "ESP32 {} 尚未写入 Fays 序列号，拒绝按端口猜测配对；"
+                "请先使用 WF:<serial> 写入后再扫描".format(esp_serial))
+        raise GripperFaysError(
+            "ESP32 {} 查询 Fays 序列号失败: {}".format(
+                esp_serial, response or "<empty>"))
 
     @staticmethod
-    def _bus_root(physical):
-        """"1-3.4.1" → (controller, "3")。
-
-        controller 取 /sys/bus/usb/devices/usb{bus} 的 realpath 父路径
-        （usbN 节点之上的 PCI devpath，如 .../0000:0a:00.0）——多控制器
-        机器上不同控制器的同号根端口必须区分；USB2/USB3 伴生双总线
-        （同一物理口 ESP=7-2、Fays=8-2）仍只按控制器+根端口关联，
-        不比较总线号，伴生容忍不变。
+    def _device_in_use(group):
+        """这台 Fays 是否已被运行中的会话独占（另一套 rig 的 SLAM）。
+
+        双夹爪时另一套 rig 的 SLAM 会把本设备锁一直持有到会话结束，
+        它按定义不可能是本次要打开的夹爪，但探测不了就得如实记下来。
         """
-        bus, separator, ports = str(physical or "").partition("-")
-        root = ports.split(".")[0] if separator else ""
-        if not separator:
-            return "", ""
+        port = str((group.get("ports") or {}).get("stereo_dev_port") or "")
+        if re.fullmatch(r"/dev/video[0-9]+", port) is None:
+            return False        # 节点无效留给后面的 SDK 预检去报错
         try:
-            real = os.path.realpath(
-                os.path.join("/sys", "bus", "usb", "devices", f"usb{bus}"))
-        except OSError:
-            return f"bus-{bus}", root   # sysfs 不可读时退回总线区分
-        return os.path.dirname(real), root
+            with fays_device_guard(port, timeout=0.0):
+                return False
+        except RuntimeError:
+            return True
+
+    def _probe_fays_groups_by_serial(self, groups):
+        """SuperSpeed 预检 + ``serial-only-fast`` 读出每台 Fays 的产品序列号。
+
+        预检在启动 SDK **之前**逐台做（只读 sysfs）：降级到 USB2 的设备
+        根本不该进 SDK。返回 ``(by_serial, skipped)``：skipped 是被其他
+        会话占用的设备，它们不参与匹配，但要写进错误文案。
+        """
+        for group in groups:
+            try:
+                validate_fays_superspeed(group)
+            except Exception as exc:
+                raise GripperFaysError(
+                    "Fays USB 链路预检失败，拒绝启动 SDK: "
+                    "physical={} error={}".format(
+                        group.get("physical_usb_path"), exc)) from exc
+        by_serial = {}
+        skipped = []
+        for group in groups:
+            if self._device_in_use(group):
+                skipped.append(group)
+                continue
+            ports = dict(group.get("ports") or {})
+            if not ports:
+                raise GripperFaysError(
+                    "Fays 设备组缺少 SDK 端口: {!r}".format(group))
+            try:
+                serial = str(probe_product_serial(
+                    ports,
+                    environment=build_fays_probe_env(),
+                    serial_only_fast=True,
+                ) or "").strip()
+            except Exception as exc:
+                raise GripperFaysError(
+                    "Fays SDK 产品序列号探测失败，拒绝回退到拓扑猜测: "
+                    "physical={} error={}".format(
+                        group.get("physical_usb_path"), exc)) from exc
+            if not serial:
+                raise GripperFaysError(
+                    "Fays SDK 返回空产品序列号，拒绝继续: physical={}".format(
+                        group.get("physical_usb_path")))
+            if serial in by_serial:
+                raise GripperFaysError(
+                    "Fays SDK 返回重复产品序列号，拒绝猜测归属: "
+                    "serial={}".format(serial))
+            by_serial[serial] = group
+        return by_serial, skipped
+
+    def _resolve_fays_group(self, esp):
+        """唯一 ESP32 → ``QF`` 绑定序列号 → 按 SDK serial 唯一匹配 Fays。
+
+        返回 ``(group, bound_serial)``。**不再按 USB 根端口关联**：Fays 是
+        USB3/FT602，插在 USB3 口时走 5000M 伴生总线，bus 号与 ESP/触觉
+        相机的 480M 总线不同；多控制器机器上两套 rig 又经常落在同号根
+        端口，按端口关联只会互相误配。
+        """
+        groups = tuple(discover_fays_device_groups())
+        if not groups:
+            raise GripperFaysError(
+                "未发现完整的 Fays S80M（stereo + IMU 两个节点必须同时在线）")
+        bound = self._query_esp_bound_fays_serial(esp)
+        by_serial, skipped = self._probe_fays_groups_by_serial(groups)
+        group = by_serial.get(bound)
+        if group is None:
+            online = ", ".join(sorted(by_serial)) or "<无>"
+            detail = ""
+            if skipped:
+                detail = "；另有正在被占用的 Fays 未能探测: [{}]".format(
+                    ", ".join(
+                        "{}({})".format(
+                            item.get("physical_usb_path"),
+                            (item.get("ports") or {}).get("stereo_dev_port"))
+                        for item in skipped))
+            raise GripperFaysError(
+                "ESP32 {} 绑定的 Fays 序列号 {} 不在当前在线的 Fays 中，"
+                "拒绝按端口或枚举顺序猜测配对：在线 serial=[{}]{}".format(
+                    esp.get("serial"), bound, online, detail))
+        return group, bound
+
+    def _probe_serial(self, group, expected_serial=None):
+        """官方 SDK 完整生命周期读序列号；USB 速度不足时给出换口提示。
 
-    def _probe_serial(self, group):
-        """官方 SDK 探针读取产品序列号；USB 速度不足时给出换口提示。"""
+        ``expected_serial`` 是 ESP32 NVS 里的绑定值：Connect 路径必须复核
+        两者一致，不允许一台「碰巧在线」的 Fays 顶替绑定设备。
+        """
         try:
             speed = validate_fays_sdk_access(group)
         except Exception as exc:
@@ -234,6 +332,13 @@ class SingleFaysLease:
             raise GripperFaysError(
                 f"Fays SDK 产品序列号探测失败: {exc}"
             ) from exc
+        if expected_serial is not None and \
+                str(serial).strip() != str(expected_serial).strip():
+            raise GripperFaysError(
+                "Fays SDK 序列号与 ESP32 绑定值不一致，拒绝连接: "
+                "physical={} bound={} actual={}".format(
+                    group.get("physical_usb_path"),
+                    expected_serial, serial))
         return serial, speed
 
     def _ensure_calibration(self, serial, group):
@@ -273,8 +378,9 @@ class SingleFaysLease:
         """
         with self._lock:
             esp = self._match_esp(esp_serial)
-            group = self._discover_unique_fays_group(esp)
-            serial, _speed = self._probe_serial(group)
+            group, bound = self._resolve_fays_group(esp)
+            serial, _speed = self._probe_serial(
+                group, expected_serial=bound)
             self._logger(
                 f"[Gripper-Fays] 正在重新读取 {serial} 的厂商出厂标定…"
             )
@@ -293,8 +399,8 @@ class SingleFaysLease:
                 return dict(self._selected)
             self.release()
             esp = self._match_esp(esp_serial)
-            group = self._discover_unique_fays_group(esp)
-            serial, speed = self._probe_serial(group)
+            group, bound = self._resolve_fays_group(esp)
+            serial, speed = self._probe_serial(group, expected_serial=bound)
             sdk_yaml, orb_yaml = self._ensure_calibration(serial, group)
 
             os.makedirs(paths.FAYS_LOCK_DIR, mode=0o700, exist_ok=True)
@@ -385,23 +491,6 @@ class SingleFaysLease:
                     stream.close()
                 raise
 
-    def resolve_assignment(self, esp_serial):
-        """相机服务所需的身份 assignment（不探测、不锁租约、不校验速度）。
-
-        UvcCameraServiceManager 只把 fays identity 用作同根端口关联与
-        错误文案，从不打开 Fays 相机；此处用实时拓扑推导的物理路径即可，
-        S80M 的官方 SDK 串行探测留给 acquire()（P3 全链，含 USB3 校验）。
-        """
-        esp = self._match_esp(esp_serial)
-        group = self._discover_unique_fays_group(esp)
-        return {
-            "esp32": {"serial": str(esp["serial"])},
-            "fays": {
-                "product_serial": "runtime-unprobed",
-                "physical_usb_path": group["physical_usb_path"],
-            },
-        }
-
     def snapshot(self):
         with self._lock:
             return (

collector/core/gripper/paths.py

@@ -48,6 +48,12 @@ CAMERA_SERVICE_BINARY = os.path.join(
 DISCOVER_UVC_CONFIG_BINARY = os.path.join(
     CAMERA_SERVICE_DIR, "build", "discover-uvc-config",
 )
+# 相机服务学到的等时档位就存在这里：按「机型 × 控制器 PCI 路径 × 相机序列号」
+# 一个键一个文件。放在 GRIPPER_DIR 下而不是服务的 runtime_dir 里，因为后者
+# 每次租约释放都会被整个删掉（见 uvc_camera_service._release_lease），存那儿
+# 等于没存。C 侧按 state_dir 这个 ini 键收到它，见 camera_service.c 的
+# persist_mode_choice。
+CAMERA_MODE_STATE_DIR = os.path.join(GRIPPER_DIR, "camera_modes")
 SIGHTAC_SDK_ROOT = os.path.abspath(os.environ.get(
     "KSQ_SIGHTAC_ROOT",
     os.path.join(PACKAGE_ROOT, "sightac_sdk"),