DeepSeek V4.1 Flash
75f0fafd41
1) .mat（BIG_MAT.mat 1.29GB / 5 信号 x 16,142,471 采样）
旧链路同时驻留三份内存：整文件 fread 进 vector、整个数据集解压成字节数组、再 memcpy 成
double；外加 streams 缓存与每条信号各一份时间列拷贝。实测私有内存 +1233.9MB、117s。
现改为：
- MatHdf5::Open 用 CreateFileW + CreateFileMappingW + MapViewOfFile（MappedBytes 只读视图，
解析代码零改动；虚拟地址不等于物理内存，未访问页不驻留）；
- 新增 ReadDatasetInfo（只读元信息）+ StreamDataset(ByteSink)（连续布局 4MB 切片、
分块布局逐 chunk inflate）+ ReadDoubleStream（SDI #data# 字节流按 8 字节一组直接写 double，
7 字节尾巴处理非 8 对齐 chunk）；ReadNumbers 改为流式转换；
- MatLoader 先收集信号清单，再按（分组，时间流）合并为一个 TableBlock：时间列按内容去重、
数据列直接 move；进度改成 0-0.02 映射 / 0.02-0.98 逐流解码 / 1.0。
结果：117.3s -> 12.5s，私有内存 +1233.9MB -> +740.4MB（最终列数据 738.9MB）。
关键性能修正：SDI 的 #data# 是 dims=[N]、chunk=[N,1]，归一化后每行只有 1 字节；旧的逐行回调
（且每行分配 coordinate 向量）只有 11MB/s。把目标连续的行合并成一次回调后约 110MB/s。
顺带把 inflate 的 Huffman 解码改成 9 位快查表，并抽到新的 Deflate.hpp/.cpp 供 MF4 复用。
2) MDF4 数据块
Problem-MF4.mf4 的第二个数据组把记录写在 ##DL（数据列表，两个 ##DT：131040+504 字节）
里，旧实现只认 ##DT，整组被跳过，于是 8 个信号只读出 4 个。
新增 CollectDataSegments（递归展开 ##DL / ##HL，叶子识别 ##DT / ##DV / ##DZ）与
ReadRecordSegments（跨段拼接、压缩段先 inflate、非压缩段仍按 4MB 分块读），
压缩段的记录长度改用 max(cg_record_id_len*8, 各通道 bitOffset+bitCount) 推算（载荷是压缩长度）。
实测 8 个信号：gVP_WindowLearnSt[0] 94 行、gVR_WinOpenReq[0] 9396 行，时间列单调。
##SD（已排序数据）仍未实现，这类数据组会被跳过。
另按要求只做检查、不改代码：该文件中 gVP_WindowLearnSt[0] 与 gVR_WinOpenReq[0] 都存在
值枚举文本（##CC，cc_type=7；links[4+i] 对应 cc_val[i]），清单已写入 Documents/agent_mem.md。
3) 光标数据点标记
光标的时间读数与差值胶囊绘制在绘图区底部、且在取值标注之后绘制，靠近底部的数据点圆点
会被完全盖住。新增 MarkerCoveredByCursorLabel（圆心落入面板或重叠面积达到半个圆）
与 CoverHiddenMarker（改成向下的三角、锚点放到面板上沿上方），在原始信号与派生曲线胶囊
两处调用，语义与“数据点在视界下方”一致。
验证（全部离屏：SW_HIDE 窗口 + 只注入合成消息 + BELOW_NORMAL，不占用鼠标键盘屏幕）：
- 新增 .preflight/round4check 34/34；A/B：临时禁用 ##DL 支持 => 2 项如实失败；
临时禁用 CoverHiddenMarker => 3 项如实失败（含像素断言为 0）；
- 回归：.preflight/round3check 31/31、editcheck 20/20、check 137/137；
- make release / make debug 零警告；Build/Release/Target.exe 785,920 字节（< 800KB）。
978 lines
31 KiB
C++
978 lines
31 KiB
C++
#include "Mf4Loader.hpp"
|
||
|
||
#include "Deflate.hpp"
|
||
#include "Utf8Util.hpp"
|
||
|
||
#include <windows.h>
|
||
|
||
#include <cmath>
|
||
#include <cstdint>
|
||
#include <cstdio>
|
||
#include <cstring>
|
||
#include <functional>
|
||
#include <limits>
|
||
#include <string>
|
||
#include <vector>
|
||
|
||
namespace jdi
|
||
{
|
||
|
||
namespace
|
||
{
|
||
const double kMissingValue = std::numeric_limits<double>::quiet_NaN(); /**< 缺失值占位。 */
|
||
const std::size_t kReadChunkBytes = 4u * 1024u * 1024u; /**< 数据区流式读取块大小。 */
|
||
const std::size_t kMaxChannelsPerGroup = 4096; /**< 单个通道组的通道数上限（防损坏文件死循环）。 */
|
||
const std::size_t kMaxGroups = 65536; /**< 数据组数量上限。 */
|
||
|
||
/** MDF 块头固定长度（id + reserved + length + link_count）。 */
|
||
const std::size_t kBlockHeaderBytes = 24;
|
||
|
||
/** @brief 通道数据类型（`cn_data_type`）。 */
|
||
enum class DataType : int
|
||
{
|
||
UINT_LE = 0,
|
||
UINT_BE = 1,
|
||
INT_LE = 2,
|
||
INT_BE = 3,
|
||
FLOAT_LE = 4,
|
||
FLOAT_BE = 5,
|
||
STRING_LATIN1 = 6,
|
||
STRING_UTF8 = 7,
|
||
STRING_UTF16_LE = 8,
|
||
STRING_UTF16_BE = 9,
|
||
BYTE_ARRAY = 10,
|
||
MIME_SAMPLE = 11,
|
||
MIME_STREAM = 12
|
||
};
|
||
|
||
/** @brief 换算类型（`cc_type`）中我们支持的子集。 */
|
||
enum class ConversionType : int
|
||
{
|
||
NONE = 0, /**< 无换算（恒等）。 */
|
||
LINEAR = 1, /**< 线性：`phys = c0 + c1 * raw`。 */
|
||
RATIONAL = 2 /**< 有理式（未支持，按恒等处理）。 */
|
||
};
|
||
|
||
/**
|
||
* @brief 只读的 MDF 文件访问器（按需 seek + read，不把整个文件读进内存）。
|
||
*/
|
||
class MdfFile
|
||
{
|
||
public:
|
||
~MdfFile() { Close(); }
|
||
|
||
bool Open(const std::wstring& path, std::wstring& error)
|
||
{
|
||
m_file = _wfopen(path.c_str(), L"rb");
|
||
if (m_file == nullptr)
|
||
{
|
||
error = L"无法打开文件，请确认路径与访问权限。";
|
||
return false;
|
||
}
|
||
if (_fseeki64(m_file, 0, SEEK_END) != 0)
|
||
{
|
||
error = L"无法定位文件末尾。";
|
||
return false;
|
||
}
|
||
const long long size = _ftelli64(m_file);
|
||
if (size <= 0)
|
||
{
|
||
error = L"文件内容为空。";
|
||
return false;
|
||
}
|
||
m_size = static_cast<std::uint64_t>(size);
|
||
|
||
// ID 块：0..7 = "MDF "，8..15 = 版本号，例如 "4.10 "。
|
||
char id[8] = {};
|
||
char version[8] = {};
|
||
if (!ReadAt(0, id, sizeof(id)) || std::memcmp(id, "MDF", 3) != 0)
|
||
{
|
||
error = L"不是有效的 MDF 文件（缺少 MDF 标识）。";
|
||
return false;
|
||
}
|
||
if (!ReadAt(8, version, sizeof(version)) || version[0] != '4')
|
||
{
|
||
error = L"仅支持 MDF v4 格式（当前文件不是 v4）。";
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void Close()
|
||
{
|
||
if (m_file != nullptr)
|
||
{
|
||
std::fclose(m_file);
|
||
m_file = nullptr;
|
||
}
|
||
}
|
||
|
||
std::uint64_t Size() const { return m_size; }
|
||
|
||
/** @brief 读取一段原始字节。 */
|
||
bool ReadAt(std::uint64_t offset, void* dst, std::size_t bytes) const
|
||
{
|
||
if (m_file == nullptr || offset + bytes > m_size)
|
||
{
|
||
return false;
|
||
}
|
||
if (_fseeki64(m_file, static_cast<long long>(offset), SEEK_SET) != 0)
|
||
{
|
||
return false;
|
||
}
|
||
return std::fread(dst, 1, bytes, m_file) == bytes;
|
||
}
|
||
|
||
/** @brief 读取一个小端标量（最多 8 字节）。越界返回 0。 */
|
||
std::uint64_t Scalar(std::uint64_t offset, std::size_t bytes) const
|
||
{
|
||
unsigned char buffer[8] = {};
|
||
if (bytes == 0 || bytes > 8 || !ReadAt(offset, buffer, bytes))
|
||
{
|
||
return 0;
|
||
}
|
||
std::uint64_t value = 0;
|
||
for (std::size_t i = 0; i < bytes; ++i)
|
||
{
|
||
value |= static_cast<std::uint64_t>(buffer[i]) << (8u * i);
|
||
}
|
||
return value;
|
||
}
|
||
|
||
std::uint32_t U32(std::uint64_t offset) const
|
||
{
|
||
return static_cast<std::uint32_t>(Scalar(offset, 4));
|
||
}
|
||
std::uint16_t U16(std::uint64_t offset) const
|
||
{
|
||
return static_cast<std::uint16_t>(Scalar(offset, 2));
|
||
}
|
||
std::uint8_t U8(std::uint64_t offset) const
|
||
{
|
||
return static_cast<std::uint8_t>(Scalar(offset, 1));
|
||
}
|
||
std::uint64_t U64(std::uint64_t offset) const { return Scalar(offset, 8); }
|
||
|
||
double F64(std::uint64_t offset) const
|
||
{
|
||
const std::uint64_t bits = U64(offset);
|
||
double value = 0.0;
|
||
std::memcpy(&value, &bits, sizeof(value));
|
||
return value;
|
||
}
|
||
|
||
/** @brief 读取块标识（4 字节 ASCII）。 */
|
||
bool BlockId(std::uint64_t offset, char out[5]) const
|
||
{
|
||
out[0] = out[1] = out[2] = out[3] = '?';
|
||
out[4] = '\0';
|
||
return ReadAt(offset, out, 4);
|
||
}
|
||
|
||
/** @brief 块总长度（含块头）。 */
|
||
std::uint64_t BlockLength(std::uint64_t offset) const { return U64(offset + 8); }
|
||
/** @brief 块内链接数量。 */
|
||
std::uint64_t LinkCount(std::uint64_t offset) const { return U64(offset + 16); }
|
||
/** @brief 第 `index` 个链接（绝对文件偏移，0 表示空）。 */
|
||
std::uint64_t Link(std::uint64_t offset, std::uint64_t index) const
|
||
{
|
||
if (index >= LinkCount(offset))
|
||
{
|
||
return 0;
|
||
}
|
||
return U64(offset + kBlockHeaderBytes + 8u * index);
|
||
}
|
||
/** @brief 块的数据段起始偏移。 */
|
||
std::uint64_t DataOffset(std::uint64_t offset) const
|
||
{
|
||
return offset + kBlockHeaderBytes + 8u * LinkCount(offset);
|
||
}
|
||
|
||
/**
|
||
* @brief 判断某个偏移是否为一个有效块的开头（且标识匹配）。
|
||
* @param [IN] offset 候选偏移。
|
||
* @param [IN] id 期望的 4 字节标识（如 "##CN"）；空字符串表示只校验偏移合法性。
|
||
*/
|
||
bool IsBlock(std::uint64_t offset, const char* id) const
|
||
{
|
||
if (offset == 0 || offset + kBlockHeaderBytes > m_size)
|
||
{
|
||
return false;
|
||
}
|
||
char actual[5] = {};
|
||
if (!BlockId(offset, actual))
|
||
{
|
||
return false;
|
||
}
|
||
if (id != nullptr && id[0] != '\0' && std::memcmp(actual, id, 4) != 0)
|
||
{
|
||
return false;
|
||
}
|
||
return BlockLength(offset) >= kBlockHeaderBytes && offset + BlockLength(offset) <= m_size;
|
||
}
|
||
|
||
/** @brief 读取 `##TX` / `##MD` 块里的文本（MDF 的 TEXT 块）。 */
|
||
std::wstring TextBlock(std::uint64_t offset) const
|
||
{
|
||
std::wstring text;
|
||
if (!IsBlock(offset, "##TX"))
|
||
{
|
||
return text;
|
||
}
|
||
const std::uint64_t data = DataOffset(offset);
|
||
const std::uint64_t usable = BlockLength(offset) - (data - offset);
|
||
if (usable < 2)
|
||
{
|
||
return text;
|
||
}
|
||
|
||
// MDF 规范里 TX 的数据段是「长度 + 文本」，长度可能是字符数（UTF-16）或字节数
|
||
//（UTF-8，MDF 4.1 起）。但部分工具（如 CANape 16）会**直接写 NUL 结尾的
|
||
// 原始文本、不带长度前缀**，因此这里按「先按规范、再按裸文本回退」的顺序解析。
|
||
if (usable >= 4)
|
||
{
|
||
const std::uint64_t declared = U32(data);
|
||
if (declared > 0 && 4u + 2u * declared <= usable)
|
||
{
|
||
// 长度前缀 + UTF-16 代码单元。
|
||
std::vector<char> buffer(static_cast<std::size_t>(2u * declared));
|
||
if (!ReadAt(data + 4, buffer.data(), buffer.size()))
|
||
{
|
||
return text;
|
||
}
|
||
text.reserve(static_cast<std::size_t>(declared));
|
||
for (std::uint64_t i = 0; i < declared; ++i)
|
||
{
|
||
const wchar_t c =
|
||
static_cast<wchar_t>(static_cast<unsigned char>(buffer[2 * i]) |
|
||
(static_cast<unsigned char>(buffer[2 * i + 1]) << 8));
|
||
if (c == L'\0')
|
||
{
|
||
break;
|
||
}
|
||
text.push_back(c);
|
||
}
|
||
return text;
|
||
}
|
||
if (declared > 0 && 4u + declared <= usable)
|
||
{
|
||
// 长度前缀 + UTF-8 字节。
|
||
std::vector<char> buffer(static_cast<std::size_t>(declared) + 1u, '\0');
|
||
if (!ReadAt(data + 4, buffer.data(), static_cast<std::size_t>(declared)))
|
||
{
|
||
return text;
|
||
}
|
||
return Utf8ToWide(buffer.data(), static_cast<int>(declared));
|
||
}
|
||
}
|
||
|
||
// 回退：数据段直接是 NUL 结尾的文本（UTF-16 或 UTF-8）。
|
||
std::vector<unsigned char> buffer(static_cast<std::size_t>(usable));
|
||
if (!ReadAt(data, buffer.data(), buffer.size()))
|
||
{
|
||
return text;
|
||
}
|
||
const bool utf16 = (buffer.size() >= 2 && buffer[1] == 0 && buffer[0] != 0);
|
||
if (utf16)
|
||
{
|
||
for (std::size_t i = 0; i + 1 < buffer.size(); i += 2)
|
||
{
|
||
const wchar_t c = static_cast<wchar_t>(buffer[i] | (buffer[i + 1] << 8));
|
||
if (c == L'\0')
|
||
{
|
||
break;
|
||
}
|
||
text.push_back(c);
|
||
}
|
||
return text;
|
||
}
|
||
std::string raw;
|
||
for (const unsigned char c : buffer)
|
||
{
|
||
if (c == '\0')
|
||
{
|
||
break;
|
||
}
|
||
raw += static_cast<char>(c);
|
||
}
|
||
return Utf8ToWide(raw.data(), static_cast<int>(raw.size()));
|
||
}
|
||
|
||
private:
|
||
FILE* m_file = nullptr;
|
||
std::uint64_t m_size = 0;
|
||
};
|
||
|
||
/** @brief 一个通道的读取方案（已从 CN 块解析出来）。 */
|
||
struct ChannelSpec
|
||
{
|
||
std::wstring name; /**< 通道名（`cn_tx_name`）。 */
|
||
std::size_t bitOffset = 0; /**< 记录内的起始位偏移（= byte_offset*8 + bit_offset）。 */
|
||
std::size_t bitCount = 0; /**< 位宽。 */
|
||
DataType dataType = DataType::UINT_LE; /**< 原始数据类型。 */
|
||
bool allInvalid = false; /**< `cn_flags & 1`：整列无效。 */
|
||
bool hasInvalidBit = false; /**< `cn_flags & 2`：有无效位。 */
|
||
std::size_t invalidBitPos = 0; /**< 无效位的绝对位偏移。 */
|
||
bool syncMaster = false; /**< `cn_sync_type == 1`：时间主通道。 */
|
||
bool linearConversion = false; /**< 是否带线性换算。 */
|
||
double offset = 0.0; /**< 线性换算常数项。 */
|
||
double factor = 1.0; /**< 线性换算系数（无法换算时为 1）。 */
|
||
/** 数值有效性：只有整数与浮点通道可以绘制。 */
|
||
bool numeric = false;
|
||
};
|
||
|
||
/** @brief 判断数据类型是否为可绘制的数值类型。 */
|
||
bool IsNumericType(DataType type)
|
||
{
|
||
return type == DataType::UINT_LE || type == DataType::UINT_BE || type == DataType::INT_LE ||
|
||
type == DataType::INT_BE || type == DataType::FLOAT_LE || type == DataType::FLOAT_BE;
|
||
}
|
||
|
||
/**
|
||
* @brief 按位从记录缓冲中取出一个数值。
|
||
*
|
||
* 支持 1–64 位整数（任意位偏移）与 32/64 位浮点（字节对齐）。
|
||
*
|
||
* @param [IN] record 记录起始指针。
|
||
* @param [IN] recordBytes 记录长度（字节），用于边界检查。
|
||
* @param [IN] spec 通道读取方案。
|
||
* @return 原始数值；越界或类型不支持时返回 NaN。
|
||
*/
|
||
double DecodeRawValue(const unsigned char* record, std::size_t recordBytes, const ChannelSpec& spec)
|
||
{
|
||
const std::size_t bitEnd = spec.bitOffset + spec.bitCount;
|
||
if (spec.bitCount == 0 || spec.bitCount > 64 || bitEnd > recordBytes * 8u)
|
||
{
|
||
return kMissingValue;
|
||
}
|
||
const std::size_t byteStart = spec.bitOffset / 8u;
|
||
const std::size_t byteCount = (bitEnd - byteStart * 8u + 7u) / 8u;
|
||
unsigned char buffer[9] = {};
|
||
std::memcpy(buffer, record + byteStart, byteCount);
|
||
|
||
if (spec.dataType == DataType::FLOAT_LE || spec.dataType == DataType::FLOAT_BE)
|
||
{
|
||
if (spec.bitOffset % 8u != 0u || (spec.bitCount != 32u && spec.bitCount != 64u))
|
||
{
|
||
return kMissingValue;
|
||
}
|
||
if (spec.dataType == DataType::FLOAT_LE)
|
||
{
|
||
if (spec.bitCount == 32u)
|
||
{
|
||
std::uint32_t bits = 0;
|
||
std::memcpy(&bits, buffer, 4);
|
||
float value = 0.0f;
|
||
std::memcpy(&value, &bits, 4);
|
||
return static_cast<double>(value);
|
||
}
|
||
double value = 0.0;
|
||
std::memcpy(&value, buffer, 8);
|
||
return value;
|
||
}
|
||
if (spec.bitCount == 32u)
|
||
{
|
||
std::uint32_t bits = (static_cast<std::uint32_t>(buffer[0]) << 24) |
|
||
(static_cast<std::uint32_t>(buffer[1]) << 16) |
|
||
(static_cast<std::uint32_t>(buffer[2]) << 8) |
|
||
static_cast<std::uint32_t>(buffer[3]);
|
||
float value = 0.0f;
|
||
std::memcpy(&value, &bits, 4);
|
||
return static_cast<double>(value);
|
||
}
|
||
std::uint64_t bits = 0;
|
||
for (int i = 0; i < 8; ++i)
|
||
{
|
||
bits = (bits << 8) | static_cast<std::uint64_t>(buffer[i]);
|
||
}
|
||
double value = 0.0;
|
||
std::memcpy(&value, &bits, 8);
|
||
return value;
|
||
}
|
||
|
||
// 整数：先按字节序拼成一个 64 位无符号数，再按位偏移右移并解释符号。
|
||
std::uint64_t raw = 0;
|
||
if (spec.dataType == DataType::UINT_LE || spec.dataType == DataType::INT_LE)
|
||
{
|
||
for (std::size_t i = byteCount; i-- > 0;)
|
||
{
|
||
raw = (raw << 8) | static_cast<std::uint64_t>(buffer[i]);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (std::size_t i = 0; i < byteCount; ++i)
|
||
{
|
||
raw = (raw << 8) | static_cast<std::uint64_t>(buffer[i]);
|
||
}
|
||
}
|
||
const std::size_t shift = spec.bitOffset % 8u;
|
||
raw >>= shift;
|
||
if (spec.bitCount < 64u)
|
||
{
|
||
raw &= (1ull << spec.bitCount) - 1ull;
|
||
}
|
||
|
||
const bool signedType = (spec.dataType == DataType::INT_LE || spec.dataType == DataType::INT_BE);
|
||
if (signedType && spec.bitCount < 64u && (raw & (1ull << (spec.bitCount - 1u))) != 0u)
|
||
{
|
||
// 符号扩展。
|
||
raw |= ~((1ull << spec.bitCount) - 1ull);
|
||
}
|
||
if (signedType)
|
||
{
|
||
return static_cast<double>(static_cast<std::int64_t>(raw));
|
||
}
|
||
return static_cast<double>(raw);
|
||
}
|
||
|
||
/** @brief 解析一个 CN 块为读取方案。 */
|
||
bool ParseChannel(const MdfFile& file, std::uint64_t cn, ChannelSpec& spec)
|
||
{
|
||
if (!file.IsBlock(cn, "##CN"))
|
||
{
|
||
return false;
|
||
}
|
||
const std::uint64_t data = file.DataOffset(cn);
|
||
const std::uint8_t type = file.U8(data + 0);
|
||
const std::uint8_t sync = file.U8(data + 1);
|
||
const std::uint8_t dataType = file.U8(data + 2);
|
||
const std::uint8_t bitOffset = file.U8(data + 3);
|
||
const std::uint32_t byteOffset = file.U32(data + 4);
|
||
const std::uint32_t bitCount = file.U32(data + 8);
|
||
const std::uint32_t flags = file.U32(data + 12);
|
||
const std::uint32_t invalidBit = file.U32(data + 16);
|
||
|
||
spec.name = file.TextBlock(file.Link(cn, 2));
|
||
spec.dataType = static_cast<DataType>(dataType);
|
||
spec.bitCount = bitCount;
|
||
spec.bitOffset = static_cast<std::size_t>(byteOffset) * 8u + bitOffset;
|
||
spec.allInvalid = (flags & 0x1u) != 0u;
|
||
spec.hasInvalidBit = (flags & 0x2u) != 0u;
|
||
spec.invalidBitPos = invalidBit;
|
||
spec.syncMaster = (sync == 1);
|
||
|
||
// 换算：只支持“无换算”与“线性”。
|
||
const std::uint64_t cc = file.Link(cn, 4);
|
||
if (file.IsBlock(cc, "##CC"))
|
||
{
|
||
const std::uint64_t ccData = file.DataOffset(cc);
|
||
const std::uint8_t ccType = file.U8(ccData + 0);
|
||
const std::uint16_t valCount = file.U16(ccData + 6);
|
||
if (ccType == static_cast<std::uint8_t>(ConversionType::LINEAR) && valCount >= 2)
|
||
{
|
||
spec.linearConversion = true;
|
||
spec.offset = file.F64(ccData + 24);
|
||
spec.factor = file.F64(ccData + 32);
|
||
if (spec.factor == 0.0 && spec.offset == 0.0)
|
||
{
|
||
// 换算表未填写：按恒等处理，避免整列变成 0。
|
||
spec.linearConversion = false;
|
||
spec.offset = 0.0;
|
||
spec.factor = 1.0;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 通道类型 2 = 虚拟主通道（CANape 的时间轴），同样可以取值。
|
||
spec.numeric = IsNumericType(spec.dataType) && spec.bitCount > 0 && spec.bitCount <= 64;
|
||
(void)type;
|
||
return true;
|
||
}
|
||
|
||
/** @brief 在一条 `next` 链上迭代块偏移（带访问次数上限，避免损坏文件死循环）。 */
|
||
template <typename Fn>
|
||
void WalkChain(const MdfFile& file, std::uint64_t first, const char* expectedId, std::size_t limit,
|
||
Fn&& visit)
|
||
{
|
||
std::uint64_t current = first;
|
||
std::size_t guard = 0;
|
||
while (current != 0 && guard++ < limit)
|
||
{
|
||
if (!file.IsBlock(current, expectedId))
|
||
{
|
||
break;
|
||
}
|
||
if (!visit(current))
|
||
{
|
||
break;
|
||
}
|
||
current = file.Link(current, 0);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 一段原始记录数据（MDF4 的 `##DT` / `##DZ` / `##DV` 块的数据区）。
|
||
*
|
||
* MDF4 允许把记录拆到多段里：
|
||
* * `##DT` 普通数据块（记录连续存放）；
|
||
* * `##DZ` 压缩数据块（zlib 流，解压后是普通记录）；
|
||
* * `##DV` 数据值块（`##DL` 列表指向的原始值）；
|
||
* * `##DL` 数据列表（链接到多个 `##DT` / `##DZ`）；
|
||
* * `##HL` 头部列表（链接到多个数据块，含压缩的）。
|
||
*/
|
||
struct DataSegment
|
||
{
|
||
std::uint64_t offset = 0; /**< 数据区起始绝对偏移。 */
|
||
std::uint64_t bytes = 0; /**< 数据区字节数（压缩段为压缩后长度）。 */
|
||
bool compressed = false; /**< 是否 need inflate。 */
|
||
};
|
||
|
||
/**
|
||
* @brief 递归展开数据块，收集所有数据段。
|
||
*
|
||
* ⚠️ 用户 2026-10-19 报告：Simulink SDI 导出的 MF4 把记录写在 `##DL`（数据列表）
|
||
* 里，而旧实现只认 `##DT` ⇒ 整个数据组被跳过（8 个信号只能读出 4 个）。
|
||
*/
|
||
bool CollectDataSegments(const MdfFile& file, std::uint64_t block,
|
||
std::vector<DataSegment>& out, int depth)
|
||
{
|
||
if (block == 0 || depth > 4 || !file.IsBlock(block, ""))
|
||
{
|
||
return false;
|
||
}
|
||
char id[5] = {};
|
||
file.BlockId(block, id);
|
||
const std::uint64_t data = file.DataOffset(block);
|
||
const std::uint64_t payload = file.BlockLength(block) - (data - block);
|
||
if (payload == 0)
|
||
{
|
||
return false;
|
||
}
|
||
if (std::memcmp(id, "##DT", 4) == 0 || std::memcmp(id, "##DV", 4) == 0)
|
||
{
|
||
out.push_back(DataSegment{data, payload, false});
|
||
return true;
|
||
}
|
||
if (std::memcmp(id, "##DZ", 4) == 0)
|
||
{
|
||
out.push_back(DataSegment{data, payload, true});
|
||
return true;
|
||
}
|
||
if (std::memcmp(id, "##DL", 4) == 0 || std::memcmp(id, "##HL", 4) == 0)
|
||
{
|
||
const std::uint64_t links = file.LinkCount(block);
|
||
bool any = false;
|
||
for (std::uint64_t index = 0; index < links && index < 1000000; ++index)
|
||
{
|
||
any = CollectDataSegments(file, file.Link(block, index), out, depth + 1) || any;
|
||
}
|
||
return any;
|
||
}
|
||
// `##SD`（已排序数据）、`##SI` 等不在支持范围内：跳过该数据组。
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* @brief 依次从若干数据段中读取连续记录，并对每条完整记录调用 `visit`。
|
||
*
|
||
* * 记录可能**跨段**（`##DT` 载荷不是记录长度的整数倍时）⇒ 用 `carry` 拼接；
|
||
* * 压缩段先用内置 inflate 展开（`##DZ`），再按普通字节流消费。
|
||
*
|
||
* @return 成功读取到至少 `cycles` 条记录返回 true。
|
||
*/
|
||
bool ReadRecordSegments(
|
||
const MdfFile& file, const std::vector<DataSegment>& segments, std::uint64_t cycles,
|
||
std::size_t recordBytes,
|
||
const std::function<void(const unsigned char* record, std::uint64_t row)>& visit)
|
||
{
|
||
if (recordBytes == 0 || cycles == 0)
|
||
{
|
||
return false;
|
||
}
|
||
std::vector<unsigned char> carry(recordBytes);
|
||
std::size_t carryBytes = 0;
|
||
std::uint64_t row = 0;
|
||
std::vector<std::uint8_t> inflated;
|
||
|
||
for (const DataSegment& segment : segments)
|
||
{
|
||
if (row >= cycles)
|
||
{
|
||
break;
|
||
}
|
||
const unsigned char* data = nullptr;
|
||
std::size_t bytes = 0;
|
||
if (segment.compressed)
|
||
{
|
||
std::vector<std::uint8_t> compressed(static_cast<std::size_t>(segment.bytes));
|
||
if (!file.ReadAt(segment.offset, compressed.data(), compressed.size()))
|
||
{
|
||
return false;
|
||
}
|
||
if (!InflateZlib(compressed.data(), compressed.size(), inflated))
|
||
{
|
||
return false;
|
||
}
|
||
data = inflated.data();
|
||
bytes = inflated.size();
|
||
}
|
||
else
|
||
{
|
||
if (segment.offset + segment.bytes > file.Size())
|
||
{
|
||
return false;
|
||
}
|
||
// 非压缩段同样分块读，避免一次分配整段（巨型数据组可能是 GB 级）。
|
||
std::vector<unsigned char> buffer;
|
||
std::uint64_t consumed = 0;
|
||
while (consumed < segment.bytes && row < cycles)
|
||
{
|
||
const std::size_t want = static_cast<std::size_t>(
|
||
std::min<std::uint64_t>(kReadChunkBytes, segment.bytes - consumed));
|
||
buffer.resize(std::max<std::size_t>(want, recordBytes));
|
||
if (!file.ReadAt(segment.offset + consumed, buffer.data(), want))
|
||
{
|
||
return false;
|
||
}
|
||
data = buffer.data();
|
||
bytes = want;
|
||
|
||
std::size_t position = 0;
|
||
while (position < bytes && row < cycles)
|
||
{
|
||
const std::size_t need = recordBytes - carryBytes;
|
||
const std::size_t take = std::min(need, bytes - position);
|
||
std::memcpy(carry.data() + carryBytes, data + position, take);
|
||
carryBytes += take;
|
||
position += take;
|
||
if (carryBytes == recordBytes)
|
||
{
|
||
visit(carry.data(), row++);
|
||
carryBytes = 0;
|
||
}
|
||
}
|
||
consumed += want;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// 压缩段：整段已在内存里，直接消费。
|
||
std::size_t position = 0;
|
||
while (position < bytes && row < cycles)
|
||
{
|
||
const std::size_t need = recordBytes - carryBytes;
|
||
const std::size_t take = std::min(need, bytes - position);
|
||
std::memcpy(carry.data() + carryBytes, data + position, take);
|
||
carryBytes += take;
|
||
position += take;
|
||
if (carryBytes == recordBytes)
|
||
{
|
||
visit(carry.data(), row++);
|
||
carryBytes = 0;
|
||
}
|
||
}
|
||
}
|
||
return row > 0;
|
||
}
|
||
|
||
/** @brief 一个通道组（CG）解析出的时间轴 + 信号列。 */
|
||
struct ChannelGroupData
|
||
{
|
||
std::wstring timeName; /**< 时间列名（主通道名或 `time`）。 */
|
||
std::vector<ChannelSpec> channels; /**< 非时间通道。 */
|
||
std::vector<double> time; /**< 时间轴数值。 */
|
||
std::vector<std::vector<double>> values; /**< 每个非时间通道的采样值。 */
|
||
};
|
||
|
||
/**
|
||
* @brief 读取一个通道组的全部记录（流式，按 4MB 分块）。
|
||
*
|
||
* @param [IN] file 文件访问器。
|
||
* @param [IN] dt 数据块偏移（`##DT`），记录从 `DataOffset(dt)` 开始连续存放。
|
||
* @param [IN] cycles 记录条数。
|
||
* @param [IN] recordBytes 单条记录字节数。
|
||
* @param [IN,OUT] group 输出（`timeName`/`channels` 已填好，函数填充 `time`/`values`）。
|
||
*/
|
||
bool ReadChannelGroupRecords(const MdfFile& file, const std::vector<DataSegment>& segments,
|
||
std::uint64_t cycles, std::size_t recordBytes,
|
||
std::size_t masterIndex, ChannelGroupData& group)
|
||
{
|
||
if (cycles == 0 || recordBytes == 0 || segments.empty())
|
||
{
|
||
return false;
|
||
}
|
||
group.time.assign(static_cast<std::size_t>(cycles), kMissingValue);
|
||
group.values.assign(group.channels.size(),
|
||
std::vector<double>(static_cast<std::size_t>(cycles), kMissingValue));
|
||
|
||
// ⚠️ 记录可能分散在多个 `##DT` / `##DZ`（经 `##DL` / `##HL` 列表）中，
|
||
// 由 `ReadRecordSegments` 负责跨段拼接与解压（见该函数的说明）。
|
||
return ReadRecordSegments(
|
||
file, segments, cycles, recordBytes,
|
||
[&group, masterIndex, recordBytes](const unsigned char* record, std::uint64_t row)
|
||
{
|
||
// 时间主通道。
|
||
{
|
||
const ChannelSpec& master = group.channels[masterIndex];
|
||
double value = DecodeRawValue(record, recordBytes, master);
|
||
if (master.allInvalid)
|
||
{
|
||
value = kMissingValue;
|
||
}
|
||
else if (master.hasInvalidBit)
|
||
{
|
||
const std::size_t byteIndex = master.invalidBitPos / 8u;
|
||
if (byteIndex < recordBytes &&
|
||
((record[byteIndex] >> (master.invalidBitPos % 8u)) & 1u) != 0u)
|
||
{
|
||
value = kMissingValue;
|
||
}
|
||
}
|
||
if (std::isfinite(value))
|
||
{
|
||
value = master.linearConversion ? (master.offset + master.factor * value) : value;
|
||
}
|
||
group.time[static_cast<std::size_t>(row)] = value;
|
||
}
|
||
|
||
// 各信号通道。
|
||
for (std::size_t c = 0; c < group.channels.size(); ++c)
|
||
{
|
||
if (c == masterIndex)
|
||
{
|
||
continue;
|
||
}
|
||
const ChannelSpec& spec = group.channels[c];
|
||
double value = DecodeRawValue(record, recordBytes, spec);
|
||
if (spec.allInvalid)
|
||
{
|
||
value = kMissingValue;
|
||
}
|
||
else if (spec.hasInvalidBit)
|
||
{
|
||
const std::size_t byteIndex = spec.invalidBitPos / 8u;
|
||
if (byteIndex < recordBytes &&
|
||
((record[byteIndex] >> (spec.invalidBitPos % 8u)) & 1u) != 0u)
|
||
{
|
||
value = kMissingValue;
|
||
}
|
||
}
|
||
if (std::isfinite(value))
|
||
{
|
||
value = spec.linearConversion ? (spec.offset + spec.factor * value) : value;
|
||
}
|
||
group.values[c][static_cast<std::size_t>(row)] = value;
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* @brief 从通道组里选出时间主通道。
|
||
* @return 主通道下标；找不到时返回 `channels.size()`（表示没有可用时间轴）。
|
||
*/
|
||
std::size_t SelectMasterChannel(const std::vector<ChannelSpec>& channels)
|
||
{
|
||
for (std::size_t i = 0; i < channels.size(); ++i)
|
||
{
|
||
if (channels[i].syncMaster && channels[i].numeric)
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
for (std::size_t i = 0; i < channels.size(); ++i)
|
||
{
|
||
if (!channels[i].numeric)
|
||
{
|
||
continue;
|
||
}
|
||
std::wstring lower;
|
||
lower.reserve(channels[i].name.size());
|
||
for (const wchar_t c : channels[i].name)
|
||
{
|
||
lower.push_back((c >= L'A' && c <= L'Z') ? static_cast<wchar_t>(c - L'A' + L'a') : c);
|
||
}
|
||
if (lower == L"time" || lower == L"t" || lower == L"timestamp")
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
return channels.size();
|
||
}
|
||
} // namespace
|
||
|
||
bool LoadMf4Source(const std::wstring& filePath, LoadedSource& source, std::wstring& error,
|
||
const LoadProgress& progress)
|
||
{
|
||
source = LoadedSource();
|
||
error.clear();
|
||
|
||
MdfFile file;
|
||
if (!file.Open(filePath, error))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
const std::size_t slashPos = filePath.find_last_of(L"\\/");
|
||
source.sourceName = (slashPos == std::wstring::npos) ? filePath : filePath.substr(slashPos + 1);
|
||
|
||
// 头块 → 第一个数据组。
|
||
std::uint64_t hd = 0;
|
||
{
|
||
char id[5] = {};
|
||
// 头块通常紧跟在 64 字节 ID 块之后；用一个小的扫描窗口定位，兼容前置填充。
|
||
for (std::uint64_t offset = 24; offset + 64 <= file.Size() && offset < 4096; offset += 8)
|
||
{
|
||
if (file.BlockId(offset, id) && std::memcmp(id, "##HD", 4) == 0)
|
||
{
|
||
hd = offset;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (hd == 0)
|
||
{
|
||
error = L"未找到 MDF 头块（##HD）。";
|
||
return false;
|
||
}
|
||
|
||
const std::uint64_t firstDg = file.Link(hd, 0);
|
||
std::size_t groupCount = 0;
|
||
WalkChain(file, firstDg, "##DG", kMaxGroups,
|
||
[&](std::uint64_t dg)
|
||
{
|
||
++groupCount;
|
||
const std::uint64_t cg = file.Link(dg, 1);
|
||
const std::uint64_t dataBlock = file.Link(dg, 2);
|
||
if (!file.IsBlock(cg, "##CG") || dataBlock == 0)
|
||
{
|
||
return true; // 跳过不完整的数据组
|
||
}
|
||
|
||
// 记录可能写在 `##DT` / `##DL`（数据列表）/ `##HL`（头部列表）/ `##DZ`（压缩）里：
|
||
// 旧实现只认 `##DT`，于是用 `##DL` 存放记录的文件会**整组被跳过**
|
||
//（用户 2026-10-19 报告：Simulink SDI 导出的 8 个信号只读出 4 个）。
|
||
std::vector<DataSegment> segments;
|
||
if (!CollectDataSegments(file, dataBlock, segments, 0) || segments.empty())
|
||
{
|
||
return true; // 不支持的数据布局（如 ##SD）⇒ 跳过该组
|
||
}
|
||
|
||
const std::uint64_t cgData = file.DataOffset(cg);
|
||
const std::uint64_t cycles = file.U64(cgData + 8);
|
||
if (cycles == 0)
|
||
{
|
||
return true;
|
||
}
|
||
const std::uint64_t recordIdBytes = file.U8(cgData); // `cg_record_id_len`
|
||
std::uint64_t payload = 0;
|
||
bool anyCompressed = false;
|
||
for (const DataSegment& segment : segments)
|
||
{
|
||
payload += segment.bytes;
|
||
anyCompressed = anyCompressed || segment.compressed;
|
||
}
|
||
|
||
// 解析通道链。
|
||
std::vector<ChannelSpec> channels;
|
||
WalkChain(file, file.Link(cg, 1), "##CN", kMaxChannelsPerGroup,
|
||
[&](std::uint64_t cn)
|
||
{
|
||
ChannelSpec spec;
|
||
if (ParseChannel(file, cn, spec))
|
||
{
|
||
channels.push_back(std::move(spec));
|
||
}
|
||
return true;
|
||
});
|
||
if (channels.empty())
|
||
{
|
||
return true;
|
||
}
|
||
|
||
// 记录长度：优先用「数据块大小 / 记录数」反推（最可靠），
|
||
// ⚠️ 压缩段（`##DZ`）的载荷是压缩后长度，不能用来反推 ⇒ 改为按通道位宽推算。
|
||
std::size_t recordBytes = 0;
|
||
if (!anyCompressed && payload % cycles == 0 && payload / cycles > 0)
|
||
{
|
||
recordBytes = static_cast<std::size_t>(payload / cycles);
|
||
}
|
||
else
|
||
{
|
||
std::size_t bits = static_cast<std::size_t>(recordIdBytes) * 8u;
|
||
for (const ChannelSpec& spec : channels)
|
||
{
|
||
bits = std::max(bits, spec.bitOffset + spec.bitCount);
|
||
}
|
||
recordBytes = (bits + 31u) / 32u * 4u;
|
||
}
|
||
if (recordBytes == 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
const std::size_t masterIndex = SelectMasterChannel(channels);
|
||
if (masterIndex >= channels.size())
|
||
{
|
||
return true; // 没有可用时间轴通道
|
||
}
|
||
|
||
ChannelGroupData group;
|
||
group.timeName = channels[masterIndex].name;
|
||
if (group.timeName.empty())
|
||
{
|
||
group.timeName = L"time";
|
||
}
|
||
group.channels = std::move(channels);
|
||
if (!ReadChannelGroupRecords(file, segments, cycles, recordBytes, masterIndex, group))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
// 组织成一个时间轴块：时间列 + 其余数值通道。
|
||
TableBlock block;
|
||
block.timeHeader = group.timeName;
|
||
block.table.headers.push_back(group.timeName);
|
||
block.table.columns.push_back(std::move(group.time));
|
||
for (std::size_t c = 0; c < group.channels.size(); ++c)
|
||
{
|
||
if (c == masterIndex || !group.channels[c].numeric)
|
||
{
|
||
continue;
|
||
}
|
||
std::wstring name = group.channels[c].name;
|
||
if (name.empty())
|
||
{
|
||
name = L"Channel" + std::to_wstring(c + 1);
|
||
}
|
||
block.table.headers.push_back(name);
|
||
block.table.columns.push_back(std::move(group.values[c]));
|
||
}
|
||
if (block.table.columns.size() < 2)
|
||
{
|
||
return true; // 只有时间列：没有可绘制信号
|
||
}
|
||
block.table.rowCount = static_cast<std::size_t>(cycles);
|
||
source.blocks.push_back(std::move(block));
|
||
|
||
if (progress)
|
||
{
|
||
LoadProgressInfo info;
|
||
info.ratio = (groupCount > 0) ? std::min(1.0, static_cast<double>(groupCount) / 64.0)
|
||
: 0.0;
|
||
info.hasBytes = false;
|
||
if (!progress(info))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
});
|
||
|
||
if (source.blocks.empty())
|
||
{
|
||
error = L"未在文件中找到可绘制的数值通道。";
|
||
return false;
|
||
}
|
||
|
||
if (progress)
|
||
{
|
||
LoadProgressInfo info;
|
||
info.ratio = 1.0;
|
||
progress(info);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
} // namespace jdi
|