264 lines
13 KiB
Python
264 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
"""Read-only CV181X Release/default/PSP configuration inventory and graph audit."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
import re
|
|
import subprocess
|
|
from functools import lru_cache
|
|
from pathlib import Path
|
|
|
|
|
|
def digest(path: Path) -> str:
|
|
return hashlib.sha256(path.read_bytes()).hexdigest()
|
|
|
|
|
|
def git_provenance(root: Path | None):
|
|
if root is None:
|
|
return None
|
|
def git(*args):
|
|
return subprocess.run(["git", "-C", str(root), *args], capture_output=True,
|
|
text=True, check=True).stdout.strip()
|
|
return {"path": str(root.resolve()), "commit": git("rev-parse", "HEAD"),
|
|
"dirty_paths": git("status", "--short", "--untracked-files=all").splitlines()}
|
|
|
|
|
|
def load(path: Path):
|
|
if not path.is_file() or path.is_symlink():
|
|
raise ValueError(f"需要普通 JSON 文件: {path}")
|
|
return json.loads(path.read_text(encoding="utf-8"))
|
|
|
|
|
|
def leaves(value, prefix=""):
|
|
if isinstance(value, dict):
|
|
for key, item in value.items():
|
|
yield from leaves(item, f"{prefix}.{key}" if prefix else key)
|
|
elif isinstance(value, list):
|
|
for index, item in enumerate(value):
|
|
yield from leaves(item, f"{prefix}[{index}]")
|
|
else:
|
|
yield prefix, value
|
|
|
|
|
|
def config_files(profile: Path, root_name: str):
|
|
paths = [profile / root_name, *sorted((profile / "configs").glob("*.json"))]
|
|
if root_name == "profile.json":
|
|
paths.append(profile / "AiPlugin.json")
|
|
if not paths[0].is_file() or not (profile / "configs").is_dir():
|
|
raise ValueError(f"Release profile 不完整: {profile}")
|
|
return {path.relative_to(profile).as_posix(): path for path in paths if path.is_file()}
|
|
|
|
|
|
@lru_cache(maxsize=2)
|
|
def source_index(source_root: Path, profile_name: str) -> dict[str, list[str]]:
|
|
index: dict[str, list[str]] = {}
|
|
pattern = re.compile(r'\[\s*"([^"]+)"\s*\]')
|
|
chip_root = source_root / "chip/cvitek/cv181x"
|
|
build = source_root / "profile" / profile_name / "build.cmake"
|
|
selected = set()
|
|
if build.is_file():
|
|
build_text = build.read_text(encoding="utf-8", errors="replace")
|
|
for variant in re.findall(r'aux_source_directory\([^\n]*/chip/\$\{ChipManufactory\}/\$\{ChipSerial\}/([^\s)]+)', build_text):
|
|
selected.add(profile_name if variant == "${Profile}" else variant)
|
|
paths = set(chip_root.glob("*.cpp"))
|
|
for variant in selected:
|
|
paths.update((chip_root / variant).glob("*.cpp"))
|
|
for path in sorted(paths):
|
|
for number, line in enumerate(path.read_text(encoding="utf-8", errors="replace").splitlines(), 1):
|
|
for key in pattern.findall(line):
|
|
index.setdefault(key, []).append(f"{path.relative_to(source_root)}:{number}")
|
|
return index
|
|
|
|
|
|
def source_hits(source_root: Path | None, profile_name: str, key: str) -> list[str]:
|
|
return source_index(source_root, profile_name).get(key, [])[:12] if source_root is not None else []
|
|
|
|
|
|
def profile_inventory(profile: Path, root_name: str, source_profile: Path | None, source_root: Path | None):
|
|
result = {}
|
|
drift = []
|
|
for relative, path in config_files(profile, root_name).items():
|
|
source_path = source_profile / relative if source_profile and relative != "AiPlugin.json" else None
|
|
if source_path is not None and (not source_path.is_file() or digest(path) != digest(source_path)):
|
|
drift.append(relative)
|
|
rows = []
|
|
for field, default in leaves(load(path)):
|
|
key = re.split(r"\.|\[", field)[-1]
|
|
rows.append({
|
|
"field": field,
|
|
"release_default": default,
|
|
"type": type(default).__name__,
|
|
"source_hits_hint_only": source_hits(source_root, profile.name, key),
|
|
})
|
|
result[relative] = {"sha256": digest(path), "fields": rows}
|
|
return result, drift
|
|
|
|
|
|
def check_graph(media_system, media_files, ai_files):
|
|
errors = []
|
|
if not isinstance(media_system, list) or not media_system:
|
|
return ["system.json 必须包含至少一个 System 通道"]
|
|
for system_index, system in enumerate(media_system):
|
|
groups = {g["vpssGrp"]: g for g in system.get("vpss", {}).get("group", [])}
|
|
pools = len(system.get("vb", []))
|
|
for group_id, group in groups.items():
|
|
for attach in group.get("attachPool", []):
|
|
if attach.get("chn", -1) not in range(len(group.get("chn", []))):
|
|
errors.append(f"System[{system_index}] VPSS {group_id} attachPool.chn 不存在")
|
|
if attach.get("pool", -1) not in range(pools):
|
|
errors.append(f"System[{system_index}] VPSS {group_id} attachPool.pool 不存在")
|
|
for bind in group.get("bind", []):
|
|
parent = groups.get(bind.get("group"))
|
|
if parent is None or bind.get("chn", -1) not in range(len(parent.get("chn", []))):
|
|
errors.append(f"System[{system_index}] VPSS {group_id} bind 来源不存在")
|
|
for relative in ("configs/venc.json", "configs/snap.json", "configs/osd.json", "configs/draw.json"):
|
|
for index, item in enumerate(media_files.get(relative, [])):
|
|
attr = item.get("attr", item)
|
|
group_id = attr.get("VpssGrp")
|
|
channel = attr.get("VpssChn")
|
|
if group_id is not None and (group_id not in groups or channel not in range(len(groups[group_id].get("chn", [])))):
|
|
errors.append(f"{relative}[{index}] VPSS {group_id}/{channel} 不存在")
|
|
enabled = ai_files.get("configs/config.json", {})
|
|
for relative, items in ai_files.items():
|
|
if relative == "configs/config.json" or not isinstance(items, list):
|
|
continue
|
|
module = Path(relative).stem
|
|
if enabled.get(module) is not True:
|
|
continue
|
|
for index, item in enumerate(items):
|
|
if not isinstance(item, dict) or "vpssGrp" not in item:
|
|
continue
|
|
group_id, channel = item["vpssGrp"], item.get("vpssChn")
|
|
if group_id not in groups or channel not in range(len(groups[group_id].get("chn", []))):
|
|
errors.append(f"{relative}[{index}] VPSS {group_id}/{channel} 不存在")
|
|
return errors
|
|
|
|
|
|
def model_references(ai_files, ai_meta, psp=None):
|
|
enabled = ai_files.get("configs/config.json", {})
|
|
declared = set(ai_meta.get("runtime", {}).get("file", []))
|
|
result = []
|
|
for relative, items in ai_files.items():
|
|
if not relative.startswith("configs/") or not isinstance(items, list):
|
|
continue
|
|
module = Path(relative).stem
|
|
if enabled.get(module) is not True:
|
|
continue
|
|
for index, item in enumerate(items):
|
|
if not isinstance(item, dict):
|
|
continue
|
|
for key, value in item.items():
|
|
if not key.endswith("ModelPath") and key != "modelPath":
|
|
continue
|
|
if not isinstance(value, str) or not value:
|
|
continue
|
|
local = (psp / "AiPlugin" / value).is_file() if psp is not None else False
|
|
result.append({"module": module, "channel": index, "field": key,
|
|
"model": value, "release_runtime_declared": value in declared,
|
|
"psp_file_present": local,
|
|
"requires_source_or_packaging_evidence": value not in declared and not local})
|
|
return result
|
|
|
|
|
|
def audit(media_profile: Path, ai_profile: Path, media_source: Path | None = None,
|
|
ai_source: Path | None = None, psp: Path | None = None):
|
|
media_profile, ai_profile = media_profile.resolve(), ai_profile.resolve()
|
|
if not media_profile.parent.name.startswith("EmxMedia-") or not ai_profile.parent.name.startswith("EmxAiPlugin-"):
|
|
raise ValueError("必须指定精确 Release 版本下的 profile，不能指定源码 profile 或 Debug")
|
|
media_root = media_profile.parent.name
|
|
ai_root = ai_profile.parent.name
|
|
media_meta = load(media_profile / "configs.json")
|
|
ai_meta = load(ai_profile / "profile.json")
|
|
ai_package = load(ai_profile / "AiPlugin.json")
|
|
if any(meta.get("ChipSerial", "").lower() != "cv181x" for meta in (media_meta, ai_meta)):
|
|
raise ValueError("当前只支持 CV181X Release")
|
|
media_source_profile = media_source / "profile" / media_profile.name if media_source else None
|
|
ai_source_profile = ai_source / "profile" / ai_profile.name if ai_source else None
|
|
media_catalog, media_drift = profile_inventory(media_profile, "configs.json", media_source_profile, media_source)
|
|
ai_catalog, ai_drift = profile_inventory(ai_profile, "profile.json", ai_source_profile, ai_source)
|
|
errors = []
|
|
for key in ("EmxSdkVersion", "ChipManufactory", "ChipSerial", "ChipSdkVersion", "Cross"):
|
|
if media_meta.get(key) != ai_meta.get(key):
|
|
errors.append(f"Media/AI {key} 不一致")
|
|
if ai_package.get("profile") != ai_profile.name or ai_package.get("version") != ai_root.removeprefix("EmxAiPlugin-"):
|
|
errors.append("AiPlugin.json 与所选 Release/profile 不一致")
|
|
media_files = {rel: load(path) for rel, path in config_files(media_profile, "configs.json").items()}
|
|
ai_files = {rel: load(path) for rel, path in config_files(ai_profile, "profile.json").items()}
|
|
errors += check_graph(media_files["configs/system.json"], media_files, ai_files)
|
|
candidate = []
|
|
model_refs = model_references(ai_files, ai_meta, psp)
|
|
if psp is not None:
|
|
psp = psp.resolve()
|
|
psp_json = load(psp / "psp.json")
|
|
for key, expected in (("EmxMediaVersion", media_root), ("EmxMediaProfile", media_profile.name),
|
|
("EmxAiPluginVersion", ai_root), ("EmxAiPluginProfile", ai_profile.name)):
|
|
if psp_json.get(key) != expected:
|
|
errors.append(f"psp.json {key} 与所选 Release 不一致")
|
|
mapping = (("media", media_files, media_catalog, psp / "configs/media/scene/default"),
|
|
("ai", ai_files, ai_catalog, psp / "AiPlugin/configs"))
|
|
effective = {"media": dict(media_files), "ai": dict(ai_files)}
|
|
for kind, defaults, catalog, target in mapping:
|
|
for relative, baseline in defaults.items():
|
|
if not relative.startswith("configs/"):
|
|
continue
|
|
path = target / Path(relative).name
|
|
if not path.is_file():
|
|
if kind == "ai":
|
|
path = psp / "AiPlugin/configs_ro" / Path(relative).name
|
|
if not path.is_file():
|
|
candidate.append({"kind": kind, "file": relative, "state": "not_in_psp_check_effective_source"})
|
|
continue
|
|
current = load(path)
|
|
effective[kind][relative] = current
|
|
baseline_fields, current_fields = dict(leaves(baseline)), dict(leaves(current))
|
|
for field in sorted(baseline_fields.keys() | current_fields.keys()):
|
|
if field not in baseline_fields or field not in current_fields or baseline_fields[field] != current_fields[field]:
|
|
candidate.append({"kind": kind, "file": str(path), "field": field,
|
|
"release_default": baseline_fields.get(field),
|
|
"candidate": current_fields.get(field),
|
|
"state": "changed_or_missing_requires_evidence"})
|
|
errors += check_graph(effective["media"]["configs/system.json"], effective["media"], effective["ai"])
|
|
model_refs = model_references(effective["ai"], ai_meta, psp)
|
|
return {
|
|
"schema_version": 1,
|
|
"scope": "read_only_static_audit_not_hardware_or_runtime_validation",
|
|
"media_release": str(media_profile), "ai_release": str(ai_profile),
|
|
"media_sha256": digest(media_profile / "configs.json"),
|
|
"ai_sha256": digest(ai_profile / "profile.json"),
|
|
"source_release_drift": {"media": media_drift, "ai": ai_drift},
|
|
"source_git": {"media": git_provenance(media_source), "ai": git_provenance(ai_source)},
|
|
"field_counts": {"media": sum(len(x["fields"]) for x in media_catalog.values()),
|
|
"ai": sum(len(x["fields"]) for x in ai_catalog.values())},
|
|
"catalog": {"media": media_catalog, "ai": ai_catalog},
|
|
"candidate_differences": candidate,
|
|
"enabled_ai_model_references": model_refs,
|
|
"errors": errors,
|
|
"passed_static_cross_checks": not errors,
|
|
}
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--media-release-profile", type=Path, required=True)
|
|
parser.add_argument("--ai-release-profile", type=Path, required=True)
|
|
parser.add_argument("--media-source", type=Path)
|
|
parser.add_argument("--ai-source", type=Path)
|
|
parser.add_argument("--psp", type=Path)
|
|
args = parser.parse_args()
|
|
try:
|
|
result = audit(args.media_release_profile, args.ai_release_profile,
|
|
args.media_source, args.ai_source, args.psp)
|
|
except (OSError, ValueError, KeyError, TypeError, json.JSONDecodeError,
|
|
subprocess.CalledProcessError) as exc:
|
|
parser.exit(2, f"audit failed: {exc}\n")
|
|
print(json.dumps(result, ensure_ascii=False, indent=2))
|
|
if result["errors"]:
|
|
parser.exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|