offscreen-android 0.0.0-stage → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +195 -2
- package/assets/injector/Injector.smali +1179 -0
- package/assets/injector/README.md +101 -0
- package/assets/injector/inject.dex +0 -0
- package/assets/overlay/ai-overlay.apk +0 -0
- package/assets/scrcpy-server.jar +0 -0
- package/bin/aim.mjs +220 -0
- package/bin/asr.mjs +81 -0
- package/bin/audcap.mjs +128 -0
- package/bin/mcp-server.mjs +410 -0
- package/bin/vdisplay.mjs +305 -0
- package/bin/vdisplayd.mjs +398 -0
- package/bin/vidcap.mjs +82 -0
- package/bin/vidgrab.mjs +172 -0
- package/package.json +55 -4
- package/src/framesrv.js +348 -0
- package/src/human.js +302 -0
- package/src/index.js +161 -0
- package/src/inject.js +415 -0
- package/src/lease.js +314 -0
- package/src/occupancy.js +214 -0
- package/src/ocr.js +209 -0
- package/src/ocr_helper.py +125 -0
- package/src/pool.js +195 -0
- package/src/sampling.js +163 -0
- package/src/stream.js +571 -0
- package/src/target.js +29 -0
- package/src/timeline.js +324 -0
- package/src/tool-spec.js +873 -0
- package/src/tools.js +2034 -0
- package/src/vd.js +2354 -0
- package/src/video.js +751 -0
- package/src/vision.js +193 -0
- package/src/vision_helper.py +334 -0
package/src/video.js
ADDED
|
@@ -0,0 +1,751 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* video.js — 从 scrcpy 的视频 socket 实时解码画面。
|
|
3
|
+
*
|
|
4
|
+
* ## 为什么需要
|
|
5
|
+
*
|
|
6
|
+
* 之前所有截图都走 `screencap`:**每帧 133-153ms,实测最高 7fps**,而且每次都要一次
|
|
7
|
+
* adb 往返。对快节奏内容(游戏、动画)等于看不见中间发生了什么。
|
|
8
|
+
*
|
|
9
|
+
* 但 `vd.js` 起 scrcpy-server 时本来就连了**两个** socket:video + control。
|
|
10
|
+
* 控制通道用来注入触摸,而视频流的数据一直是 `s.on('data', () => {})` —— **直接扔掉**。
|
|
11
|
+
*
|
|
12
|
+
* 实测这个流里是真的 H.264:3.5 秒收到 916KB,解出 97 帧 720x1592,约 28fps。
|
|
13
|
+
*
|
|
14
|
+
* ## 协议(实测出来的,不是文档抄的)
|
|
15
|
+
*
|
|
16
|
+
* 连接建立后服务端先发固定头:
|
|
17
|
+
*
|
|
18
|
+
* ```
|
|
19
|
+
* [0] dummy 字节(scrcpy 在第一个连接上发的握手字节)
|
|
20
|
+
* [1..64] 设备名,64 字节补零
|
|
21
|
+
* [65..68] 编码格式 ascii,"h264"
|
|
22
|
+
* [69..71] session 包头:0x80 = bit63 置位,表示这是 session 包
|
|
23
|
+
* [72] 低 1 位 = client_resized
|
|
24
|
+
* [73..76] 宽(u32 BE)
|
|
25
|
+
* [77..80] 高(u32 BE)
|
|
26
|
+
* [81..] 视频包
|
|
27
|
+
* ```
|
|
28
|
+
*
|
|
29
|
+
* 每个视频包:
|
|
30
|
+
*
|
|
31
|
+
* ```
|
|
32
|
+
* [0..7] u64 BE:高 3 位是 flag,低 61 位是 PTS(微秒)
|
|
33
|
+
* bit63 = session 包(尺寸变化/编码器重启时重发,本层已跳过)
|
|
34
|
+
* bit62 = config 包(SPS/PPS),这种包 PTS 是 0
|
|
35
|
+
* bit61 = 关键帧
|
|
36
|
+
* [8..11] 载荷长度(u32 BE)
|
|
37
|
+
* [12..] H.264 载荷(Annex-B,自带 00 00 00 01 起始码)
|
|
38
|
+
* ```
|
|
39
|
+
*
|
|
40
|
+
* **实测校验**:按这个结构解析,916,485 字节里切出 97 帧,offset 精确走到文件末尾(100%)。
|
|
41
|
+
*
|
|
42
|
+
* ## 用法
|
|
43
|
+
*
|
|
44
|
+
* ```js
|
|
45
|
+
* import * as video from './video.js';
|
|
46
|
+
* video.attach(socket); // 把视频 socket 的数据喂进来
|
|
47
|
+
* const jpg = video.latest(); // 拿最新一帧 JPEG(可能是 null,还没来帧)
|
|
48
|
+
* ```
|
|
49
|
+
*
|
|
50
|
+
* ## 为什么不在插件里跑 ffmpeg 解码常驻
|
|
51
|
+
*
|
|
52
|
+
* 试过两条路:
|
|
53
|
+
* ① 每个包自己解 —— 不行,H.264 有帧间依赖,必须整条流喂解码器
|
|
54
|
+
* ② 常驻 ffmpeg 子进程,边收边解 —— 可行,但 CPU 常驻(720x1592 解码约 0.3 核)
|
|
55
|
+
*
|
|
56
|
+
* 现在是**按需解码**:只在你真的要一帧时,把手上缓冲的若干包丢给 ffmpeg 解一次。
|
|
57
|
+
* 好处是闲时不耗 CPU;代价是每次要等解码(约 40-80ms,仍比 screencap 快一半)。
|
|
58
|
+
*/
|
|
59
|
+
|
|
60
|
+
const HEADER_MIN = 81; // 固定头长度(dummy 1 + 名字 64 + codec 4 + 4 + 宽 4 + 高 4)
|
|
61
|
+
|
|
62
|
+
/** 一个视频流的解析状态。 */
|
|
63
|
+
function makeState() {
|
|
64
|
+
return {
|
|
65
|
+
buf: Buffer.alloc(0), // 还没解析的原始字节
|
|
66
|
+
headerDone: false,
|
|
67
|
+
width: 0,
|
|
68
|
+
height: 0,
|
|
69
|
+
codec: '',
|
|
70
|
+
/** 最近的包,按到达顺序。每项 {pts, key, cfg, data:Buffer} */
|
|
71
|
+
packets: [],
|
|
72
|
+
/** 配置包(SPS/PPS),解码前要先喂它 */
|
|
73
|
+
config: null,
|
|
74
|
+
frames: 0, // 收到的视频帧数(不含配置包)
|
|
75
|
+
bytes: 0,
|
|
76
|
+
firstPts: null,
|
|
77
|
+
lastPts: null,
|
|
78
|
+
attachedAt: 0,
|
|
79
|
+
};
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
/*
|
|
83
|
+
* 留多少包。
|
|
84
|
+
*
|
|
85
|
+
* **不能太小。** 关键帧间隔实测约 10 秒(25fps 就是 250 帧),第一版留 120 个包,
|
|
86
|
+
* 关键帧很快被挤出去,之后所有解码都报「无输出」——因为没有 SPS/PPS 就解不了。
|
|
87
|
+
* 留 400(约 16 秒)能保证绝大多数时候缓冲里至少有一个关键帧。
|
|
88
|
+
*
|
|
89
|
+
* 内存代价:每帧平均 9KB × 400 ≈ 3.6MB,可以接受。
|
|
90
|
+
*/
|
|
91
|
+
const PACKET_KEEP = 400;
|
|
92
|
+
|
|
93
|
+
function makeStateChecked() {
|
|
94
|
+
const s = makeState();
|
|
95
|
+
return s;
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
export function createReader() {
|
|
99
|
+
return makeStateChecked();
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
/**
|
|
103
|
+
* 把收到的字节推进解析器。
|
|
104
|
+
* @param {object} st createReader() 的返回值
|
|
105
|
+
* @param {Buffer} chunk
|
|
106
|
+
*/
|
|
107
|
+
export function push(st, chunk) {
|
|
108
|
+
if (!st || !chunk || !chunk.length) return;
|
|
109
|
+
st.bytes += chunk.length;
|
|
110
|
+
st.buf = st.buf.length ? Buffer.concat([st.buf, chunk]) : chunk;
|
|
111
|
+
|
|
112
|
+
// ① 先啃固定头
|
|
113
|
+
if (!st.headerDone) {
|
|
114
|
+
if (st.buf.length < HEADER_MIN) return;
|
|
115
|
+
const b = st.buf;
|
|
116
|
+
st.width = b.readUInt32BE(73);
|
|
117
|
+
st.height = b.readUInt32BE(77);
|
|
118
|
+
st.codec = b.toString('ascii', 65, 69).replace(/\0/g, '');
|
|
119
|
+
st.headerDone = true;
|
|
120
|
+
st.attachedAt = Date.now();
|
|
121
|
+
st.buf = b.subarray(HEADER_MIN);
|
|
122
|
+
// **宽高不对就直接判失败**:宁可报错也不要拿 0x0 去解码
|
|
123
|
+
if (!(st.width > 0 && st.width < 8192 && st.height > 0 && st.height < 8192)) {
|
|
124
|
+
st.headerError = `头部宽高不合理:${st.width}x${st.height}`;
|
|
125
|
+
}
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
// ② 逐个包切
|
|
129
|
+
while (st.buf.length >= 12) {
|
|
130
|
+
const rawPts = st.buf.readBigUInt64BE(0);
|
|
131
|
+
const size = st.buf.readUInt32BE(8);
|
|
132
|
+
// 长度不合理就丢弃缓冲,等下一批(避免死循环)
|
|
133
|
+
if (size > 8 * 1024 * 1024) {
|
|
134
|
+
st.buf = Buffer.alloc(0);
|
|
135
|
+
st.badSizes = (st.badSizes || 0) + 1;
|
|
136
|
+
break;
|
|
137
|
+
}
|
|
138
|
+
if (st.buf.length < 12 + size) break; // 还没收全
|
|
139
|
+
|
|
140
|
+
/*
|
|
141
|
+
* **标志位在 u64 的高 3 位,低 61 位才是 PTS(微秒)。**
|
|
142
|
+
* 位 63 = session 包(这层已经跳过了,媒体包里不会出现)
|
|
143
|
+
* 位 62 = config 包(SPS/PPS),PTS 被清零
|
|
144
|
+
* 位 61 = 关键帧
|
|
145
|
+
* 我第一版把 63 当 config、62 当 key,分类全错位 —— 碰巧因为包顺序没变还能解出画面,
|
|
146
|
+
* 但那是运气,不是正确。
|
|
147
|
+
*/
|
|
148
|
+
const cfg = (rawPts & (1n << 62n)) !== 0n;
|
|
149
|
+
const key = (rawPts & (1n << 61n)) !== 0n;
|
|
150
|
+
const pts = Number(rawPts & ((1n << 61n) - 1n));
|
|
151
|
+
const data = st.buf.subarray(12, 12 + size);
|
|
152
|
+
|
|
153
|
+
if (cfg) {
|
|
154
|
+
// SPS/PPS:解码前必须先喂给解码器
|
|
155
|
+
st.config = Buffer.from(data);
|
|
156
|
+
// 常驻解码器在跑的话,参数集随时更新
|
|
157
|
+
feedDecoder(st, st.config, true);
|
|
158
|
+
} else {
|
|
159
|
+
st.frames += 1;
|
|
160
|
+
if (st.firstPts === null) st.firstPts = pts;
|
|
161
|
+
st.lastPts = pts;
|
|
162
|
+
// **同时记到达时刻。** scrcpy 的 PTS 高位被 flag 占了(位 63/62/61 都见过被置位),
|
|
163
|
+
// 用 PTS 算帧率会得出几十万秒这种荒谬结果,所以帧率按墙钟算。
|
|
164
|
+
const pkt = { pts, key, at: Date.now(), data: Buffer.from(data) };
|
|
165
|
+
st.packets.push(pkt);
|
|
166
|
+
if (st.packets.length > PACKET_KEEP) st.packets.shift();
|
|
167
|
+
// 喂常驻解码器(没起就不做事)
|
|
168
|
+
feedDecoder(st, pkt, false);
|
|
169
|
+
}
|
|
170
|
+
st.buf = st.buf.subarray(12 + size);
|
|
171
|
+
}
|
|
172
|
+
}
|
|
173
|
+
|
|
174
|
+
/**
|
|
175
|
+
* 视频流当前的实测帧率。
|
|
176
|
+
*
|
|
177
|
+
* **按墙钟算,不按 PTS。** 实测 scrcpy 的 PTS 高位被 flag 占用(0x4000...
|
|
178
|
+
* 是关键帧、0x2000... 也出现过),拿它当微秒数会算出几十万秒的跨度。
|
|
179
|
+
*
|
|
180
|
+
* 取最近 N 帧的到达时间窗口来算,这样「刚连上时」和「画面静止时」都不会给出虚高值。
|
|
181
|
+
*/
|
|
182
|
+
export function fps(st) {
|
|
183
|
+
if (!st || st.packets.length < 2) return 0;
|
|
184
|
+
const pk = st.packets;
|
|
185
|
+
const win = pk.slice(-30); // 最近 30 帧足以反映当前节奏
|
|
186
|
+
const dur = (win[win.length - 1].at - win[0].at) / 1000;
|
|
187
|
+
if (dur <= 0) return 0;
|
|
188
|
+
return Math.round(((win.length - 1) / dur) * 10) / 10;
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
/**
|
|
192
|
+
* 把缓冲的包拼成一条 H.264 Annex-B 流。
|
|
193
|
+
*
|
|
194
|
+
* 注意顺序:**配置包必须在最前面**,否则解码器拿不到 SPS/PPS 会解不出画面。
|
|
195
|
+
*/
|
|
196
|
+
export function h264(st, { maxPackets = 0 } = {}) {
|
|
197
|
+
if (!st) return null;
|
|
198
|
+
|
|
199
|
+
/*
|
|
200
|
+
* **必须从一个关键帧开始切,不能随便取最后 N 个包。**
|
|
201
|
+
*
|
|
202
|
+
* 第一版取 `slice(-N)`,结果 ffmpeg 报 `non-existing PPS 0 referenced` ——
|
|
203
|
+
* 关键帧里带着 SPS/PPS,把开头丢掉之后解码器就没有参数集了,一帧都解不出。
|
|
204
|
+
*
|
|
205
|
+
* 做法:从后往前找最近的关键帧,从它开始切到结尾。缓冲里没有关键帧时,
|
|
206
|
+
* 就从头取(缓冲本身是从关键帧起步的)。
|
|
207
|
+
*/
|
|
208
|
+
let start = 0;
|
|
209
|
+
for (let i = st.packets.length - 1; i >= 0; i -= 1) {
|
|
210
|
+
if (st.packets[i].key) { start = i; break; }
|
|
211
|
+
}
|
|
212
|
+
// **从关键帧到末尾整段取,不能再 slice(-N) 裁一遍。**
|
|
213
|
+
// 裁掉开头就等于又丢了 SPS/PPS。H.264 的 P 帧不能跳过,所以 GOP 有多长就取多长。
|
|
214
|
+
const pk = st.packets.slice(start);
|
|
215
|
+
|
|
216
|
+
const parts = [];
|
|
217
|
+
// 配置包(如果流里单独发过)永远放最前
|
|
218
|
+
if (st.config) parts.push(st.config);
|
|
219
|
+
for (const p of pk) parts.push(p.data);
|
|
220
|
+
if (!parts.length) return null;
|
|
221
|
+
return Buffer.concat(parts);
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
/** 状态摘要,给工具返回用 */
|
|
225
|
+
export function stats(st) {
|
|
226
|
+
if (!st) return { ok: false, hint: '没有视频流' };
|
|
227
|
+
return {
|
|
228
|
+
ok: st.headerDone && !st.headerError,
|
|
229
|
+
headerDone: st.headerDone,
|
|
230
|
+
headerError: st.headerError || null,
|
|
231
|
+
width: st.width,
|
|
232
|
+
height: st.height,
|
|
233
|
+
codec: st.codec,
|
|
234
|
+
frames: st.frames,
|
|
235
|
+
buffered: st.packets.length,
|
|
236
|
+
bytes: st.bytes,
|
|
237
|
+
fps: fps(st),
|
|
238
|
+
hasConfig: Boolean(st.config),
|
|
239
|
+
hasKeyframe: st.packets.some((p) => p.key),
|
|
240
|
+
badSizes: st.badSizes || 0,
|
|
241
|
+
};
|
|
242
|
+
}
|
|
243
|
+
|
|
244
|
+
/**
|
|
245
|
+
* 把当前缓冲解码成一张 JPEG。
|
|
246
|
+
*
|
|
247
|
+
* ## 为什么要走 ffmpeg
|
|
248
|
+
*
|
|
249
|
+
* H.264 有帧间依赖,不能只解一帧孤立地看 —— 必须给它一串连续包。这里取最近的
|
|
250
|
+
* 一批包(默认 24 帧)丢给 ffmpeg,让它解出**最后一张**,那就是「现在」的画面。
|
|
251
|
+
*
|
|
252
|
+
* ## 实测代价
|
|
253
|
+
*
|
|
254
|
+
* 720x1592、24 个包:约 40-80ms。对比 screencap 的 133-153ms,快一半以上,
|
|
255
|
+
* 而且**不占 adb 通道**(screencap 每次都要一次 adb 往返)。
|
|
256
|
+
*
|
|
257
|
+
* @param {object} st
|
|
258
|
+
* @param {object} o
|
|
259
|
+
* @param {string} [o.out] 输出路径,省略则用临时文件
|
|
260
|
+
* @param {number} [o.width=0] 缩放宽度,0 = 原始
|
|
261
|
+
* @param {number} [o.packets=24] 用最近多少包
|
|
262
|
+
* @param {number} [o.timeoutMs=8000]
|
|
263
|
+
* @returns {Promise<{ok:boolean, path?:string, bytes?:number, ms?:number, hint?:string}>}
|
|
264
|
+
*/
|
|
265
|
+
export async function grabJpeg(st, o = {}) {
|
|
266
|
+
const t0 = Date.now();
|
|
267
|
+
if (!st || !st.headerDone) return { ok: false, hint: '视频流头部还没收到' };
|
|
268
|
+
if (st.headerError) return { ok: false, hint: st.headerError };
|
|
269
|
+
if (!st.packets.length) return { ok: false, hint: '视频流里还没有帧(画面可能一直静止)' };
|
|
270
|
+
|
|
271
|
+
const { spawn } = await import('node:child_process');
|
|
272
|
+
const { writeFileSync, readFileSync, statSync } = await import('node:fs');
|
|
273
|
+
const { tmpdir } = await import('node:os');
|
|
274
|
+
const { join } = await import('node:path');
|
|
275
|
+
|
|
276
|
+
const wantPk = o.packets === undefined ? 24 : Number(o.packets);
|
|
277
|
+
const src = h264(st, { maxPackets: wantPk > 0 ? wantPk : 0 });
|
|
278
|
+
if (!src) return { ok: false, hint: '没有可解的包' };
|
|
279
|
+
|
|
280
|
+
const stamp = Date.now();
|
|
281
|
+
const out = o.out || join(tmpdir(), `vd-live-${stamp}.jpg`);
|
|
282
|
+
// 临时流放同目录、换个后缀 —— 不能把 .h264 当目录用(第一版就拼错了)
|
|
283
|
+
const tmpIn = o.out
|
|
284
|
+
? o.out.replace(/\.jpe?g$/i, '') + '.h264'
|
|
285
|
+
: join(tmpdir(), `vd-live-${stamp}.h264`);
|
|
286
|
+
try { writeFileSync(tmpIn, src); } catch (e) {
|
|
287
|
+
return { ok: false, hint: `写临时流失败:${e?.message || e}` };
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
const args = ['-hide_banner', '-loglevel', 'error', '-f', 'h264', '-i', tmpIn];
|
|
291
|
+
const w = Number(o.width) || 0;
|
|
292
|
+
if (w > 0) args.push('-vf', `scale=${w}:-1:flags=bilinear`);
|
|
293
|
+
// -vsync 0 + 取最后一帧:保证拿到的是「最新的那一刻」,不是第一帧
|
|
294
|
+
args.push('-vsync', '0', '-frames:v', '1000', '-y', out);
|
|
295
|
+
|
|
296
|
+
return await new Promise((resolve) => {
|
|
297
|
+
let err = '';
|
|
298
|
+
const p = spawn('ffmpeg', args, { stdio: ['ignore', 'ignore', 'pipe'] });
|
|
299
|
+
const timer = setTimeout(() => { try { p.kill('SIGKILL'); } catch { /* ignore */ } }, Number(o.timeoutMs) || 8000);
|
|
300
|
+
p.stderr.on('data', (d) => { err += d; });
|
|
301
|
+
p.on('close', () => {
|
|
302
|
+
clearTimeout(timer);
|
|
303
|
+
try {
|
|
304
|
+
const sz = statSync(out).size;
|
|
305
|
+
if (sz > 0) {
|
|
306
|
+
resolve({ ok: true, path: out, bytes: sz, ms: Date.now() - t0, tmpIn });
|
|
307
|
+
return;
|
|
308
|
+
}
|
|
309
|
+
} catch { /* 没产出 */ }
|
|
310
|
+
resolve({ ok: false, hint: `解码没产出(ffmpeg: ${err.slice(0, 200) || '无输出'})`, tmpIn });
|
|
311
|
+
});
|
|
312
|
+
p.on('error', (e) => {
|
|
313
|
+
clearTimeout(timer);
|
|
314
|
+
resolve({ ok: false, hint: `起不了 ffmpeg:${e?.message || e}` });
|
|
315
|
+
});
|
|
316
|
+
});
|
|
317
|
+
}
|
|
318
|
+
|
|
319
|
+
/* ============================================================
|
|
320
|
+
* 常驻解码器
|
|
321
|
+
* ============================================================
|
|
322
|
+
*
|
|
323
|
+
* ## 为什么要有它
|
|
324
|
+
*
|
|
325
|
+
* `grabJpeg()` 每次都从关键帧开始把整个 GOP 解一遍,实测 244ms —— 比 screencap
|
|
326
|
+
* 的 143ms 还慢。原因是结构性的:H.264 的帧间依赖逼你从头解。
|
|
327
|
+
*
|
|
328
|
+
* 常驻解码器让 ffmpeg 一直在跑,把新包持续喂进去,它持续吐 JPEG。拿「最新一帧」
|
|
329
|
+
* 就变成读内存,不再有解码等待。
|
|
330
|
+
*
|
|
331
|
+
* **实测(对同一份 96 帧的流)**:
|
|
332
|
+
* 一次性解整条流:96 帧 428ms → 4.5ms/帧
|
|
333
|
+
* 所以 25fps 常驻的 CPU 约 11% 一个核。
|
|
334
|
+
*
|
|
335
|
+
* ## 为什么要等关键帧
|
|
336
|
+
*
|
|
337
|
+
* ffmpeg 中途接上去的时候,手上全是 P 帧,它没有 SPS/PPS 也没有参考帧,
|
|
338
|
+
* 会报 `non-existing PPS 0 referenced` 然后一帧都出不来。
|
|
339
|
+
* 所以启动后要**先扔掉所有 P 帧,等到下一个关键帧才开始喂**。
|
|
340
|
+
*
|
|
341
|
+
* 所以启动时会用 `h264(st)`(config + 最近关键帧起的全部包)自举,让解码器立刻能工作。
|
|
342
|
+
* 自举喂进去的历史帧**按帧数跳过**,不进传感器环(时间闸不可靠,会泄漏)。
|
|
343
|
+
*
|
|
344
|
+
* 想更快拿到画面就得让服务端重发 IDR —— 往控制通道发一个 0x11 字节
|
|
345
|
+
* (TYPE_RESET_VIDEO),那需要控制 socket 配合,后面再做。
|
|
346
|
+
*/
|
|
347
|
+
|
|
348
|
+
/** 起一个常驻解码器,挂在 st 上。重复调用会先停掉旧的。 */
|
|
349
|
+
export async function startDecoder(st, o = {}) {
|
|
350
|
+
if (!st) return { ok: false, hint: '没有解析状态' };
|
|
351
|
+
if (st.decoder) return { ok: true, reused: true };
|
|
352
|
+
|
|
353
|
+
const { spawn } = await import('node:child_process');
|
|
354
|
+
/*
|
|
355
|
+
* 常驻解码器现在只出 **32x32 灰度**(每帧 1024 字节、7.6ms),
|
|
356
|
+
* 用来算画面变化量 —— 这是「免费的时间信号」:25Hz 盯着,但不花图片 token。
|
|
357
|
+
*
|
|
358
|
+
* 全尺寸 JPEG 仍走按需解码(`grabJpeg`),因为:
|
|
359
|
+
* ① 双输出(split + 两个 -map 到 pipe:1/pipe:3)实测两边都是 0 字节,不通
|
|
360
|
+
* ② 灰度流很便宜,没必要为了省一次解码而承担管道帧序对齐的风险
|
|
361
|
+
*
|
|
362
|
+
* **`-fflags nobuffer -flags low_delay` 绝对不能加。**
|
|
363
|
+
* 实测加上之后 ffmpeg 静默不出任何输出(既没报错也没帧),去掉就正常。
|
|
364
|
+
* 这个坑害我以为是解码器写错了,查了很久。
|
|
365
|
+
*/
|
|
366
|
+
const args = [
|
|
367
|
+
'-hide_banner', '-loglevel', 'error',
|
|
368
|
+
'-f', 'h264', '-i', 'pipe:0',
|
|
369
|
+
'-an', '-sn', '-dn',
|
|
370
|
+
'-vf', 'scale=32:32:flags=area,format=gray',
|
|
371
|
+
/*
|
|
372
|
+
* **`-fps_mode passthrough` 必须有。**
|
|
373
|
+
*
|
|
374
|
+
* 默认 rawvideo 输出会按恒定帧率**补帧/复制帧**,于是连续两帧内容一模一样,
|
|
375
|
+
* 灰度差恒为 0 —— 传感器看起来永远"静止"。实测就是这个现象:帧数在涨
|
|
376
|
+
* (21.6fps)、环也满了,但 mad 全是 0,滑动时也不变。
|
|
377
|
+
*
|
|
378
|
+
* passthrough 表示「解码出多少就吐多少,不补不丢」。
|
|
379
|
+
*/
|
|
380
|
+
'-fps_mode', 'passthrough',
|
|
381
|
+
'-f', 'rawvideo', '-pix_fmt', 'gray',
|
|
382
|
+
'pipe:1',
|
|
383
|
+
];
|
|
384
|
+
|
|
385
|
+
const proc = spawn('ffmpeg', args, { stdio: ['pipe', 'pipe', 'pipe'] });
|
|
386
|
+
|
|
387
|
+
const dec = {
|
|
388
|
+
proc,
|
|
389
|
+
latestAt: 0, // 最近一帧灰度的到达时间
|
|
390
|
+
frames: 0, // 解出多少张
|
|
391
|
+
needKeyframe: true, // 还没等到关键帧
|
|
392
|
+
// **必须在初始化里就赋 0。** 只在自举成功时赋值的话,自举失败(h264(st) 为 null)
|
|
393
|
+
// 就一直是 undefined,`Date.now() >= undefined` 恒为 false → pushSensor 永不调用,
|
|
394
|
+
// 传感器永久空。而 motion() 把「空」翻译成 stable:true,故障看起来跟静止一模一样。
|
|
395
|
+
skipSensorUntil: 0,
|
|
396
|
+
stderr: '',
|
|
397
|
+
closed: false,
|
|
398
|
+
bytesIn: 0,
|
|
399
|
+
startedAt: Date.now(),
|
|
400
|
+
};
|
|
401
|
+
st.decoder = dec;
|
|
402
|
+
|
|
403
|
+
// ---- stdout:每 1024 字节一帧 32x32 灰度 ----
|
|
404
|
+
const THUMB_BYTES = 32 * 32;
|
|
405
|
+
let acc = Buffer.alloc(0);
|
|
406
|
+
proc.stdout.on('data', (d) => {
|
|
407
|
+
acc = acc.length ? Buffer.concat([acc, d]) : d;
|
|
408
|
+
while (acc.length >= THUMB_BYTES) {
|
|
409
|
+
const buf = Buffer.from(acc.subarray(0, THUMB_BYTES));
|
|
410
|
+
acc = acc.subarray(THUMB_BYTES);
|
|
411
|
+
dec.frames += 1;
|
|
412
|
+
dec.latestAt = Date.now();
|
|
413
|
+
// 自举帧按数量跳过(见上面说明),跳完才开始记传感器
|
|
414
|
+
if (dec.skipFrames > 0) { dec.skipFrames -= 1; } else pushSensor(st, buf, dec);
|
|
415
|
+
}
|
|
416
|
+
// 这里原来有一行 `if (acc.length > THUMB_BYTES*4) acc = Buffer.alloc(0)`。
|
|
417
|
+
// 它是死代码(while 退出时 acc 必然 < 1024),而且**万一触发就会丢掉
|
|
418
|
+
// 非 1024 整数倍的前缀,从此永久错位**。删掉。
|
|
419
|
+
});
|
|
420
|
+
|
|
421
|
+
proc.stderr.on('data', (d) => {
|
|
422
|
+
dec.stderr = (dec.stderr + d).slice(-2000);
|
|
423
|
+
});
|
|
424
|
+
proc.on('close', () => { dec.closed = true; });
|
|
425
|
+
proc.on('error', (e) => { dec.closed = true; dec.stderr += ` spawn: ${e?.message || e}`; });
|
|
426
|
+
proc.stdin.on('error', () => { /* ffmpeg 退出后 write 会 EPIPE,忽略 */ });
|
|
427
|
+
|
|
428
|
+
/*
|
|
429
|
+
* **自举:用缓冲里已有的数据把解码器喂起来。**
|
|
430
|
+
*
|
|
431
|
+
* 只靠「等下一个关键帧」是不行的 —— 实测等了 24 秒都没等到,因为 scrcpy 的
|
|
432
|
+
* 关键帧主要在**流开始时**发,解码器启动时那个 IDR 早被消费进 packets 了。
|
|
433
|
+
*
|
|
434
|
+
* 所以启动时直接把 `config + 从最近关键帧开始的包` 灌进去,解码器立刻就能工作。
|
|
435
|
+
*/
|
|
436
|
+
const bst = h264(st);
|
|
437
|
+
if (bst && bst.length) {
|
|
438
|
+
try {
|
|
439
|
+
dec.bytesIn += bst.length;
|
|
440
|
+
proc.stdin.write(bst);
|
|
441
|
+
dec.needKeyframe = false; // 自举数据里已经含有关键帧
|
|
442
|
+
dec.bootstrapped = true;
|
|
443
|
+
/*
|
|
444
|
+
* **按帧数跳,不用时间闸。**
|
|
445
|
+
*
|
|
446
|
+
* 原来给 600ms 消化窗口:实测 dec.frames 到 258 时 sensorFrames 已经 17,
|
|
447
|
+
* 也就是 241 帧在窗口内解完、剩 17 帧漏到窗口外被当成实时帧记下。
|
|
448
|
+
* 泄漏量随 GOP 长度和 CPU 快慢漂移,不可控。
|
|
449
|
+
*
|
|
450
|
+
* 改成:自举喂了多少帧,就让解码器跳过多少帧 —— `-fps_mode passthrough`
|
|
451
|
+
* 保证出帧数与入帧数 1:1,所以这个计数是准的。
|
|
452
|
+
*/
|
|
453
|
+
dec.skipFrames = st.packets.length;
|
|
454
|
+
} catch { /* 起不来就退回等待模式 */ }
|
|
455
|
+
}
|
|
456
|
+
|
|
457
|
+
return { ok: true, bootstrapped: Boolean(dec.bootstrapped) };
|
|
458
|
+
}
|
|
459
|
+
|
|
460
|
+
/** 停掉常驻解码器。 */
|
|
461
|
+
export function stopDecoder(st) {
|
|
462
|
+
if (!st || !st.decoder) return { ok: true, stopped: false };
|
|
463
|
+
const dec = st.decoder;
|
|
464
|
+
st.decoder = null;
|
|
465
|
+
try { dec.proc.stdin.end(); } catch { /* ignore */ }
|
|
466
|
+
try { dec.proc.kill('SIGKILL'); } catch { /* ignore */ }
|
|
467
|
+
return { ok: true, stopped: true, frames: dec.frames };
|
|
468
|
+
}
|
|
469
|
+
|
|
470
|
+
/**
|
|
471
|
+
* 取最新一张 JPEG。
|
|
472
|
+
*
|
|
473
|
+
* 返回的是**内存里的 Buffer**,不落盘 —— 调用方需要文件时自己写。
|
|
474
|
+
* 这样拿一帧只有内存拷贝成本,实测远低于 1ms。
|
|
475
|
+
*/
|
|
476
|
+
export function latestJpeg(st) {
|
|
477
|
+
// 常驻解码器现在只出灰度(用来算变化量),不出 JPEG。
|
|
478
|
+
// 全尺寸帧统一走 grabJpeg 的按需解码 —— 返回 null 让调用方回退。
|
|
479
|
+
return null;
|
|
480
|
+
}
|
|
481
|
+
|
|
482
|
+
/** 常驻解码器状态 */
|
|
483
|
+
export function decoderStats(st) {
|
|
484
|
+
const dec = st && st.decoder;
|
|
485
|
+
if (!dec) return { running: false };
|
|
486
|
+
const sens = st.sensor || [];
|
|
487
|
+
return {
|
|
488
|
+
running: !dec.closed,
|
|
489
|
+
frames: dec.frames,
|
|
490
|
+
needKeyframe: dec.needKeyframe,
|
|
491
|
+
hasFrame: sens.length > 0,
|
|
492
|
+
sensorFrames: sens.length,
|
|
493
|
+
lastMad: sens.length ? sens[sens.length - 1].mad : null,
|
|
494
|
+
// **ageMs 说明不了传感器新鲜度** —— 它用的是解码器活着的时间。
|
|
495
|
+
// 真正的传感器新鲜度看 sensorAgeMs。
|
|
496
|
+
ageMs: dec.latestAt ? Date.now() - dec.latestAt : null,
|
|
497
|
+
sensorAgeMs: sens.length ? Date.now() - sens[sens.length - 1].at : null,
|
|
498
|
+
// 两路帧计数应该 1:1;2x/3x 就是解码器在重复吐帧
|
|
499
|
+
decoderFrames: dec.frames,
|
|
500
|
+
streamFrames: st.frames,
|
|
501
|
+
skipLeft: dec.skipFrames || 0,
|
|
502
|
+
uptimeMs: Date.now() - dec.startedAt,
|
|
503
|
+
stderr: dec.stderr ? dec.stderr.slice(-300) : '',
|
|
504
|
+
};
|
|
505
|
+
}
|
|
506
|
+
|
|
507
|
+
/**
|
|
508
|
+
* 把解析出的包喂给常驻解码器。由 push() 内部调用,不需要外部调。
|
|
509
|
+
*
|
|
510
|
+
* 关键规则:
|
|
511
|
+
* · config 包(SPS/PPS)**永远先写**,否则解码器没有参数集
|
|
512
|
+
* · 还没等到关键帧之前,所有 P 帧都扔掉(喂了也解不出)
|
|
513
|
+
* · 关键帧到达时,先写 config 再写它,然后才进入正常喂流
|
|
514
|
+
*/
|
|
515
|
+
/*
|
|
516
|
+
* 传感器环:每来一帧 32x32 灰度,算它和上一帧的平均绝对差(MAD),
|
|
517
|
+
* 顺带算一个粗略的「变化都在哪儿」的包围盒。
|
|
518
|
+
*
|
|
519
|
+
* 这是整个「免费时间信号」的地基:25Hz 盯着屏幕,但一个 token 都不花。
|
|
520
|
+
* 后面所有决策(要不要截图、截哪儿、截几张)都从这里来。
|
|
521
|
+
*
|
|
522
|
+
* 内存:每帧存 1024 字节灰度 + 几个数字,100 帧约 110KB。
|
|
523
|
+
*/
|
|
524
|
+
export const SENSOR_KEEP = 100; // 约 4 秒 @25fps
|
|
525
|
+
|
|
526
|
+
function pushSensor(st, gray, dec) {
|
|
527
|
+
if (!st) return;
|
|
528
|
+
if (!st.sensor) st.sensor = [];
|
|
529
|
+
const prev = st.sensor.length ? st.sensor[st.sensor.length - 1] : null;
|
|
530
|
+
|
|
531
|
+
// 顺手把亮度统计出来:全 0 = 黑屏(FLAG_SECURE),min==max = 纯色(卡住)
|
|
532
|
+
let sum = 0, min = 255, max = 0;
|
|
533
|
+
for (let k = 0; k < 1024; k += 1) {
|
|
534
|
+
const v = gray[k];
|
|
535
|
+
sum += v;
|
|
536
|
+
if (v < min) min = v;
|
|
537
|
+
if (v > max) max = v;
|
|
538
|
+
}
|
|
539
|
+
const mean = Math.round((sum / 1024) * 10) / 10;
|
|
540
|
+
|
|
541
|
+
let mad = 0;
|
|
542
|
+
let bbox = null;
|
|
543
|
+
if (prev) {
|
|
544
|
+
let sum = 0;
|
|
545
|
+
let minX = 32, minY = 32, maxX = -1, maxY = -1;
|
|
546
|
+
// 判定「这个像素变了」的阈值:32x32 上 8 灰阶差已经很明显
|
|
547
|
+
const TH = 8;
|
|
548
|
+
for (let y = 0; y < 32; y += 1) {
|
|
549
|
+
for (let x = 0; x < 32; x += 1) {
|
|
550
|
+
const i = y * 32 + x;
|
|
551
|
+
const d = Math.abs(gray[i] - prev.gray[i]);
|
|
552
|
+
sum += d;
|
|
553
|
+
if (d >= TH) {
|
|
554
|
+
if (x < minX) minX = x;
|
|
555
|
+
if (x > maxX) maxX = x;
|
|
556
|
+
if (y < minY) minY = y;
|
|
557
|
+
if (y > maxY) maxY = y;
|
|
558
|
+
}
|
|
559
|
+
}
|
|
560
|
+
}
|
|
561
|
+
mad = sum / 1024;
|
|
562
|
+
if (maxX >= 0) bbox = { minX, minY, maxX, maxY };
|
|
563
|
+
}
|
|
564
|
+
|
|
565
|
+
st.sensor.push({ at: Date.now(), mad, bbox, mean, min, max, gray });
|
|
566
|
+
if (st.sensor.length > SENSOR_KEEP) st.sensor.shift();
|
|
567
|
+
if (dec) dec.lastMad = mad;
|
|
568
|
+
}
|
|
569
|
+
|
|
570
|
+
/**
|
|
571
|
+
* 最近的变化曲线(给决策用)。
|
|
572
|
+
*
|
|
573
|
+
* 返回的是数值,**不含任何图片** —— 用它决定要不要花 token,本身就是免费的。
|
|
574
|
+
*/
|
|
575
|
+
export function motion(st, { recent = 25 } = {}) {
|
|
576
|
+
const sens = (st && st.sensor) || [];
|
|
577
|
+
/*
|
|
578
|
+
* **传感器空 ≠ 出错。**
|
|
579
|
+
*
|
|
580
|
+
* scrcpy 只在画面变化时发帧。屏幕一直静止的时候一个包都没有,传感器环自然空。
|
|
581
|
+
* 这时候正确的结论是「没有任何变化」,而不是「探测失败」—— 后者会让调用方
|
|
582
|
+
* 白白回退到昂贵路径。
|
|
583
|
+
*/
|
|
584
|
+
if (!sens.length) {
|
|
585
|
+
/*
|
|
586
|
+
* **空要分两种情况,不能一律当"稳定"。**
|
|
587
|
+
*
|
|
588
|
+
* · 解码器没在跑 → 没数据是正常的(没开这项能力)
|
|
589
|
+
* · 解码器在跑但传感器空 → **可能坏了**(比如自举失败导致 pushSensor 从不被调用)
|
|
590
|
+
*
|
|
591
|
+
* 原来两种情况都返回 stable:true,于是"传感器坏了"看起来跟"画面静止"一模一样 ——
|
|
592
|
+
* 这种故障最难查。现在用 degraded 标出来。
|
|
593
|
+
*/
|
|
594
|
+
const dec = st && st.decoder;
|
|
595
|
+
const running = Boolean(dec && !dec.closed);
|
|
596
|
+
return {
|
|
597
|
+
ok: !(running && dec.frames > 0),
|
|
598
|
+
frames: 0,
|
|
599
|
+
windowFrames: 0,
|
|
600
|
+
peakMad: 0, avgMad: 0, tailMad: 0,
|
|
601
|
+
stable: true,
|
|
602
|
+
changing: false,
|
|
603
|
+
spanMs: 0, fps: null,
|
|
604
|
+
lastBbox: null,
|
|
605
|
+
degraded: running && dec.frames > 0, // 解码器出过帧但传感器收不到 = 坏了
|
|
606
|
+
hint: running
|
|
607
|
+
? `解码器已解 ${dec.frames} 帧但传感器是空的 —— 传感器链路可能坏了(看 degraded)`
|
|
608
|
+
: '传感器还没有任何帧(解码器没在跑,或画面一直静止)',
|
|
609
|
+
};
|
|
610
|
+
}
|
|
611
|
+
const win = sens.slice(-recent);
|
|
612
|
+
const mads = win.map((s) => s.mad).filter((v, i) => i > 0 || win.length > 1);
|
|
613
|
+
const peak = mads.length ? Math.max(...mads) : 0;
|
|
614
|
+
const avg = mads.length ? mads.reduce((a, b) => a + b, 0) / mads.length : 0;
|
|
615
|
+
// 用后 1/4 的平均值判断「稳没稳」
|
|
616
|
+
const tail = win.slice(-Math.max(2, Math.ceil(win.length / 4)));
|
|
617
|
+
const tailMad = tail.reduce((a, s) => a + s.mad, 0) / Math.max(1, tail.length);
|
|
618
|
+
return {
|
|
619
|
+
ok: true,
|
|
620
|
+
frames: sens.length,
|
|
621
|
+
windowFrames: win.length,
|
|
622
|
+
peakMad: Math.round(peak * 100) / 100,
|
|
623
|
+
avgMad: Math.round(avg * 100) / 100,
|
|
624
|
+
tailMad: Math.round(tailMad * 100) / 100,
|
|
625
|
+
stable: tailMad < 0.5,
|
|
626
|
+
changing: tailMad >= 0.5,
|
|
627
|
+
spanMs: win.length > 1 ? win[win.length - 1].at - win[0].at : 0,
|
|
628
|
+
/*
|
|
629
|
+
* **帧率必须用 ≥1 秒的窗口算。**
|
|
630
|
+
*
|
|
631
|
+
* socket 的 data 事件是批量到达的(64KB ≈ 64 帧,同一批时间戳只差 0-1ms)。
|
|
632
|
+
* 用 25 帧的跨度算,一碰到批量边界 span 就塌成 173ms → 得出 138fps;
|
|
633
|
+
* 下个窗口正常 → 19-21fps。69/138/21.8/19.2 全是这么来的。
|
|
634
|
+
*/
|
|
635
|
+
fps: (() => {
|
|
636
|
+
if (sens.length < 2) return 0;
|
|
637
|
+
const last = sens[sens.length - 1].at;
|
|
638
|
+
// 从最后往前找到第一个 ≥1000ms 之前的帧
|
|
639
|
+
let i = sens.length - 1;
|
|
640
|
+
while (i > 0 && last - sens[i].at < 1000) i -= 1;
|
|
641
|
+
const span = last - sens[i].at;
|
|
642
|
+
if (span < 900 || i === sens.length - 1) return null; // 窗口不够 1 秒就不给数
|
|
643
|
+
return Math.round(((sens.length - 1 - i) / (span / 1000)) * 10) / 10;
|
|
644
|
+
})(),
|
|
645
|
+
lastBbox: win.length ? win[win.length - 1].bbox : null,
|
|
646
|
+
// 最后一次的亮度:全 0 = 黑屏(FLAG_SECURE),min==max = 纯色(卡住)
|
|
647
|
+
lastMean: win.length ? win[win.length - 1].mean : null,
|
|
648
|
+
lastMin: win.length ? win[win.length - 1].min : null,
|
|
649
|
+
lastMax: win.length ? win[win.length - 1].max : null,
|
|
650
|
+
blackScreen: win.length ? win[win.length - 1].max === 0 : null,
|
|
651
|
+
};
|
|
652
|
+
}
|
|
653
|
+
|
|
654
|
+
/**
|
|
655
|
+
* 变化热力图:最后两帧之间,32×32 每一格的灰度差。
|
|
656
|
+
*
|
|
657
|
+
* ## 为什么需要
|
|
658
|
+
*
|
|
659
|
+
* `bbox` 只给一个包围盒。当画面在大范围里动(比如横屏时的首页、滚动中的长列表),
|
|
660
|
+
* 包围盒会覆盖大半个屏,按面积比例算就「太大、不值得裁」——于是放弃裁切,
|
|
661
|
+
* 退化成全屏缩放,白白丢掉「裁剪 = 1:1 像素」的清晰度红利。
|
|
662
|
+
*
|
|
663
|
+
* 有了热力图就能在大包围盒里**挑一块最值得看的 544² 子区**,
|
|
664
|
+
* 而不是要么裁小的、要么放弃。
|
|
665
|
+
*
|
|
666
|
+
* @returns {Float32Array|null} 长度 1024(32×32 行优先),每格 0-255 的差值
|
|
667
|
+
*/
|
|
668
|
+
export function changeHeatmap(st) {
|
|
669
|
+
const sens = (st && st.sensor) || [];
|
|
670
|
+
if (sens.length < 2) return null;
|
|
671
|
+
const a = sens[sens.length - 2].gray;
|
|
672
|
+
const b = sens[sens.length - 1].gray;
|
|
673
|
+
if (!a || !b) return null;
|
|
674
|
+
const out = new Float32Array(1024);
|
|
675
|
+
let total = 0;
|
|
676
|
+
for (let i = 0; i < 1024; i += 1) {
|
|
677
|
+
const d = Math.abs(b[i] - a[i]);
|
|
678
|
+
out[i] = d;
|
|
679
|
+
total += d;
|
|
680
|
+
}
|
|
681
|
+
if (total <= 0) return null;
|
|
682
|
+
return out;
|
|
683
|
+
}
|
|
684
|
+
|
|
685
|
+
/**
|
|
686
|
+
* 在变化热力图里找「最密集的一块」。
|
|
687
|
+
*
|
|
688
|
+
* 用滑动窗口累加:格子边长 winCells,找总和最大的位置。
|
|
689
|
+
* 32×32 上找 544² 对应约多少格,由调用方按屏宽换算后传进来。
|
|
690
|
+
*
|
|
691
|
+
* @param {object} st
|
|
692
|
+
* @param {number} winCells 窗口边长(格),1-32
|
|
693
|
+
* @returns {{cx:number, cy:number, score:number}|null} 格子坐标中心 + 该窗口的总变化量
|
|
694
|
+
*/
|
|
695
|
+
export function densestCellWindow(st, winCells) {
|
|
696
|
+
const hm = changeHeatmap(st);
|
|
697
|
+
if (!hm) return null;
|
|
698
|
+
const k = Math.max(1, Math.min(32, Math.round(winCells)));
|
|
699
|
+
if (k >= 32) return { cx: 16, cy: 16, score: 1 };
|
|
700
|
+
|
|
701
|
+
// 先算二维前缀和,滑动窗口就是 O(1)
|
|
702
|
+
const pre = new Float64Array((32 + 1) * (32 + 1));
|
|
703
|
+
for (let y = 0; y < 32; y += 1) {
|
|
704
|
+
for (let x = 0; x < 32; x += 1) {
|
|
705
|
+
pre[(y + 1) * 33 + (x + 1)] = hm[y * 32 + x]
|
|
706
|
+
+ pre[y * 33 + (x + 1)]
|
|
707
|
+
+ pre[(y + 1) * 33 + x]
|
|
708
|
+
- pre[y * 33 + x];
|
|
709
|
+
}
|
|
710
|
+
}
|
|
711
|
+
const sum = (x0, y0, x1, y1) => pre[(y1 + 1) * 33 + (x1 + 1)]
|
|
712
|
+
- pre[y0 * 33 + (x1 + 1)] - pre[(y1 + 1) * 33 + x0] + pre[y0 * 33 + x0];
|
|
713
|
+
|
|
714
|
+
let best = -1;
|
|
715
|
+
let bx = 0;
|
|
716
|
+
let by = 0;
|
|
717
|
+
for (let y = 0; y + k <= 32; y += 1) {
|
|
718
|
+
for (let x = 0; x + k <= 32; x += 1) {
|
|
719
|
+
const v = sum(x, y, x + k - 1, y + k - 1);
|
|
720
|
+
if (v > best) { best = v; bx = x; by = y; }
|
|
721
|
+
}
|
|
722
|
+
}
|
|
723
|
+
if (best <= 0) return null;
|
|
724
|
+
return { cx: bx + k / 2, cy: by + k / 2, score: best };
|
|
725
|
+
}
|
|
726
|
+
|
|
727
|
+
export function feedDecoder(st, pkt, isConfig) {
|
|
728
|
+
const dec = st && st.decoder;
|
|
729
|
+
if (!dec || dec.closed) return;
|
|
730
|
+
const sin = dec.proc.stdin;
|
|
731
|
+
if (!sin || sin.destroyed) return;
|
|
732
|
+
|
|
733
|
+
const write = (buf) => {
|
|
734
|
+
if (!buf || !buf.length) return;
|
|
735
|
+
dec.bytesIn += buf.length;
|
|
736
|
+
try { sin.write(buf); } catch { /* ffmpeg 走了就忽略 */ }
|
|
737
|
+
};
|
|
738
|
+
|
|
739
|
+
if (isConfig) {
|
|
740
|
+
// 配置包随时可以写,解码器会更新参数集
|
|
741
|
+
write(pkt);
|
|
742
|
+
return;
|
|
743
|
+
}
|
|
744
|
+
|
|
745
|
+
if (dec.needKeyframe) {
|
|
746
|
+
if (!pkt.key) return; // 还没到关键帧,扔掉
|
|
747
|
+
if (st.config) write(st.config); // 先给 SPS/PPS
|
|
748
|
+
dec.needKeyframe = false;
|
|
749
|
+
}
|
|
750
|
+
write(pkt.data);
|
|
751
|
+
}
|