mirror of
https://github.com/dz0ny/meshcore-sar.git
synced 2026-07-28 22:39:38 +00:00
324 lines
9.9 KiB
Dart
324 lines
9.9 KiB
Dart
import 'dart:typed_data';
|
|
|
|
const int _maxCompanionFrameBytes = 172; // MeshCore MAX_FRAME_SIZE
|
|
const int _cmdSendRawDataOverheadBytes = 2; // cmd + pathLen
|
|
const int _maxMeshPacketPayloadBytes = 184; // MeshCore MAX_PACKET_PAYLOAD
|
|
|
|
/// Compressed image format used in the image packet protocol.
|
|
enum ImageFormat {
|
|
avif(0, 'AVIF'),
|
|
jpeg(1, 'JPEG');
|
|
|
|
const ImageFormat(this.id, this.label);
|
|
final int id;
|
|
final String label;
|
|
|
|
static ImageFormat fromId(int id) => ImageFormat.values.firstWhere(
|
|
(f) => f.id == id,
|
|
orElse: () => ImageFormat.avif,
|
|
);
|
|
}
|
|
|
|
/// A single binary fragment of a compressed image.
|
|
///
|
|
/// Binary format (direct contacts, via pushRawData / cmdSendRawData):
|
|
/// [0x49 'I'][sessionId:4B][fmt:1B][idx:1B][total:1B][imageData...]
|
|
///
|
|
/// Legacy default is 152 data bytes per fragment.
|
|
class ImagePacket {
|
|
final String sessionId; // 8 hex chars (4 bytes)
|
|
final ImageFormat format;
|
|
final int index; // 0-based
|
|
final int total; // total fragment count (1..255)
|
|
final Uint8List data;
|
|
|
|
const ImagePacket({
|
|
required this.sessionId,
|
|
required this.format,
|
|
required this.index,
|
|
required this.total,
|
|
required this.data,
|
|
});
|
|
|
|
static const int _magic = 0x49; // 'I'
|
|
static const int _headerLen = 8; // magic(1)+session(4)+fmt(1)+idx(1)+total(1)
|
|
static const int maxDataBytes =
|
|
152; // Conservative default for compatibility.
|
|
|
|
static bool isImageBinary(Uint8List payload) =>
|
|
payload.isNotEmpty && payload[0] == _magic;
|
|
|
|
static ImagePacket? tryParseBinary(Uint8List payload) {
|
|
if (payload.length < _headerLen) return null;
|
|
if (payload[0] != _magic) return null;
|
|
try {
|
|
final sessionId = payload
|
|
.sublist(1, 5)
|
|
.map((b) => b.toRadixString(16).padLeft(2, '0'))
|
|
.join();
|
|
final fmtId = payload[5];
|
|
final index = payload[6];
|
|
final total = payload[7];
|
|
if (total < 1) return null;
|
|
return ImagePacket(
|
|
sessionId: sessionId,
|
|
format: ImageFormat.fromId(fmtId),
|
|
index: index,
|
|
total: total,
|
|
data: payload.sublist(_headerLen),
|
|
);
|
|
} catch (_) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
Uint8List encodeBinary() {
|
|
final sessionBytes = Uint8List(4);
|
|
for (var i = 0; i < 4; i++) {
|
|
sessionBytes[i] = int.parse(
|
|
sessionId.substring(i * 2, i * 2 + 2),
|
|
radix: 16,
|
|
);
|
|
}
|
|
final out = Uint8List(_headerLen + data.length);
|
|
out[0] = _magic;
|
|
out.setRange(1, 5, sessionBytes);
|
|
out[5] = format.id;
|
|
out[6] = index;
|
|
out[7] = total;
|
|
out.setRange(_headerLen, out.length, data);
|
|
return out;
|
|
}
|
|
|
|
@override
|
|
String toString() =>
|
|
'ImagePacket($sessionId ${format.label} [$index/${total - 1}] ${data.length}B)';
|
|
}
|
|
|
|
/// Compute the maximum safe image data bytes for a direct route path.
|
|
///
|
|
/// This accounts for:
|
|
/// - companion command-frame limit (MAX_FRAME_SIZE=172),
|
|
/// - cmdSendRawData overhead (`cmd` + `pathLen`),
|
|
/// - image packet binary header (8 bytes),
|
|
/// - mesh packet payload limit (MAX_PACKET_PAYLOAD=184).
|
|
///
|
|
/// Path length follows Contact.outPathLen semantics: 0 = direct, 1+ = hops.
|
|
int safeImageDataBytesForPath(int pathLen) {
|
|
final normalizedPathLen = pathLen.clamp(0, 64).toInt();
|
|
final maxRawPayloadFromCommandFrame =
|
|
_maxCompanionFrameBytes -
|
|
_cmdSendRawDataOverheadBytes -
|
|
normalizedPathLen;
|
|
final maxRawPayloadFromMesh =
|
|
_maxMeshPacketPayloadBytes - ImagePacket._headerLen;
|
|
final maxRawPayload = maxRawPayloadFromCommandFrame < maxRawPayloadFromMesh
|
|
? maxRawPayloadFromCommandFrame
|
|
: maxRawPayloadFromMesh;
|
|
final maxData = maxRawPayload - ImagePacket._headerLen;
|
|
return maxData.clamp(1, 255).toInt();
|
|
}
|
|
|
|
/// Envelope announcing image availability (control plane).
|
|
///
|
|
/// Text format:
|
|
/// IE1:{sid}:{fmt}:{total}:{w}:{h}:{bytes}:{senderKey6}:{ts}:{ver}
|
|
/// Example:
|
|
/// IE1:deadbeef:0:7:128:128:1050:aabbccddeeff:1700000000:1
|
|
class ImageEnvelope {
|
|
static const String prefix = 'IE1:';
|
|
|
|
final String sessionId; // 8 hex chars
|
|
final ImageFormat format;
|
|
final int total; // total fragment count
|
|
final int width;
|
|
final int height;
|
|
final int sizeBytes; // total compressed image size
|
|
final String senderKey6; // 12 hex chars (6 bytes)
|
|
final int timestampSec;
|
|
final int version;
|
|
|
|
const ImageEnvelope({
|
|
required this.sessionId,
|
|
required this.format,
|
|
required this.total,
|
|
required this.width,
|
|
required this.height,
|
|
required this.sizeBytes,
|
|
required this.senderKey6,
|
|
required this.timestampSec,
|
|
this.version = 1,
|
|
});
|
|
|
|
static bool isEnvelope(String text) => text.startsWith(prefix);
|
|
|
|
static ImageEnvelope? tryParse(String text) {
|
|
if (!isEnvelope(text)) return null;
|
|
final body = text.substring(prefix.length);
|
|
final parts = body.split(':');
|
|
if (parts.length != 9) return null;
|
|
try {
|
|
final sid = parts[0];
|
|
final fmtId = int.tryParse(parts[1]);
|
|
final total = int.tryParse(parts[2]);
|
|
final w = int.tryParse(parts[3]);
|
|
final h = int.tryParse(parts[4]);
|
|
final bytes = int.tryParse(parts[5]);
|
|
final senderKey6 = parts[6];
|
|
final ts = int.tryParse(parts[7]);
|
|
final ver = int.tryParse(parts[8]);
|
|
|
|
if (!RegExp(r'^[0-9a-fA-F]{8}$').hasMatch(sid)) return null;
|
|
if (fmtId == null) return null;
|
|
if (total == null || total < 1 || total > 255) return null;
|
|
if (w == null || h == null || w < 1 || h < 1) return null;
|
|
if (bytes == null || bytes < 1) return null;
|
|
if (!RegExp(r'^[0-9a-fA-F]{12}$').hasMatch(senderKey6)) return null;
|
|
if (ts == null || ts <= 0) return null;
|
|
if (ver == null || ver != 1) return null;
|
|
|
|
return ImageEnvelope(
|
|
sessionId: sid.toLowerCase(),
|
|
format: ImageFormat.fromId(fmtId),
|
|
total: total,
|
|
width: w,
|
|
height: h,
|
|
sizeBytes: bytes,
|
|
senderKey6: senderKey6.toLowerCase(),
|
|
timestampSec: ts,
|
|
version: ver,
|
|
);
|
|
} catch (_) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
String encode() =>
|
|
'$prefix${sessionId.toLowerCase()}:${format.id}:$total:$width:$height:$sizeBytes:${senderKey6.toLowerCase()}:$timestampSec:$version';
|
|
}
|
|
|
|
/// Direct request to fetch image fragments (control plane).
|
|
///
|
|
/// Text format:
|
|
/// IR1:{sid}:{want}:{requesterKey6}:{ts}:{ver}
|
|
/// Example:
|
|
/// IR1:deadbeef:a:aabbccddeeff:1700000010:1
|
|
class ImageFetchRequest {
|
|
static const String prefix = 'IR1:';
|
|
|
|
final String sessionId;
|
|
final String want; // 'all' or 'missing'
|
|
final List<int> missingIndices;
|
|
final String requesterKey6; // 12 hex chars
|
|
final int timestampSec;
|
|
final int version;
|
|
|
|
const ImageFetchRequest({
|
|
required this.sessionId,
|
|
this.want = 'all',
|
|
this.missingIndices = const [],
|
|
required this.requesterKey6,
|
|
required this.timestampSec,
|
|
this.version = 1,
|
|
});
|
|
|
|
static bool isRequest(String text) => text.startsWith(prefix);
|
|
|
|
static ImageFetchRequest? tryParse(String text) {
|
|
if (!isRequest(text)) return null;
|
|
final body = text.substring(prefix.length);
|
|
final parts = body.split(':');
|
|
if (parts.length != 5) return null;
|
|
try {
|
|
final sid = parts[0];
|
|
final wantToken = parts[1];
|
|
final requesterKey6 = parts[2];
|
|
final ts = int.tryParse(parts[3]);
|
|
final ver = int.tryParse(parts[4]);
|
|
final normalizedWant = wantToken == 'a'
|
|
? 'all'
|
|
: (wantToken.startsWith('m-') ? 'missing' : wantToken);
|
|
|
|
if (!RegExp(r'^[0-9a-fA-F]{8}$').hasMatch(sid)) return null;
|
|
final missingIndices = <int>[];
|
|
if (normalizedWant == 'missing') {
|
|
final encoded = wantToken.substring(2);
|
|
if (encoded.isEmpty) return null;
|
|
for (final raw in encoded.split(',')) {
|
|
final idx = int.tryParse(raw);
|
|
if (idx == null || idx < 0 || idx > 254) return null;
|
|
missingIndices.add(idx);
|
|
}
|
|
if (missingIndices.isEmpty) return null;
|
|
} else if (normalizedWant != 'all') {
|
|
return null;
|
|
}
|
|
if (!RegExp(r'^[0-9a-fA-F]{12}$').hasMatch(requesterKey6)) return null;
|
|
if (ts == null || ts <= 0) return null;
|
|
if (ver == null || ver != 1) return null;
|
|
|
|
return ImageFetchRequest(
|
|
sessionId: sid.toLowerCase(),
|
|
want: normalizedWant,
|
|
missingIndices: missingIndices,
|
|
requesterKey6: requesterKey6.toLowerCase(),
|
|
timestampSec: ts,
|
|
version: ver,
|
|
);
|
|
} catch (_) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
String encode() {
|
|
final wantToken = want == 'missing' && missingIndices.isNotEmpty
|
|
? 'm-${missingIndices.join(',')}'
|
|
: (want == 'all' ? 'a' : want);
|
|
return '$prefix${sessionId.toLowerCase()}:$wantToken:${requesterKey6.toLowerCase()}:$timestampSec:$version';
|
|
}
|
|
}
|
|
|
|
/// Fragment the compressed image bytes into [ImagePacket] list.
|
|
///
|
|
/// [sessionId] must be 8 lowercase hex chars.
|
|
/// [format] is the image format used.
|
|
/// Returns at most 255 packets; excess bytes are silently dropped.
|
|
List<ImagePacket> fragmentImage({
|
|
required String sessionId,
|
|
required ImageFormat format,
|
|
required Uint8List bytes,
|
|
int maxDataBytes = ImagePacket.maxDataBytes,
|
|
}) {
|
|
final chunkSize = maxDataBytes.clamp(1, 255).toInt();
|
|
final chunks = <Uint8List>[];
|
|
for (var offset = 0; offset < bytes.length; offset += chunkSize) {
|
|
final end = (offset + chunkSize).clamp(0, bytes.length);
|
|
chunks.add(bytes.sublist(offset, end));
|
|
if (chunks.length == 255) break; // protocol limit
|
|
}
|
|
final total = chunks.length;
|
|
return [
|
|
for (var i = 0; i < total; i++)
|
|
ImagePacket(
|
|
sessionId: sessionId,
|
|
format: format,
|
|
index: i,
|
|
total: total,
|
|
data: chunks[i],
|
|
),
|
|
];
|
|
}
|
|
|
|
/// Reassemble image bytes from received [packets].
|
|
///
|
|
/// Returns null if any fragment is missing.
|
|
Uint8List? reassembleImage(List<ImagePacket?> packets) {
|
|
if (packets.isEmpty) return null;
|
|
if (packets.any((p) => p == null)) return null;
|
|
final merged = <int>[];
|
|
for (final p in packets) {
|
|
merged.addAll(p!.data);
|
|
}
|
|
return Uint8List.fromList(merged);
|
|
}
|