taotoolkit 1.0.0__py3-none-any.whl

taotoolkit/tao_tuning.py

@@ -0,0 +1,1344 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+"""文件与 tuning 处理功能层。"""
+
+import argparse
+import os
+import re
+import sys
+import ctypes
+import shutil
+from pathlib import Path
+from typing import Tuple, Union
+
+try:
+    import uiautomator2 as u2
+except Exception:  # pragma: no cover
+    u2 = None
+
+from .tao_common import (
+    debugCtrl,
+    ErrCode,
+    createFolder,
+    eExit,
+    fileExceptionNotFound,
+    fileExceptionillegal,
+    fileExist,
+    checkMsg,
+    findFilesWithSuffix,
+    get_file_index,
+    is_number,
+    logd,
+    loge,
+    logh,
+    logi,
+    logw,
+    logCallErr,
+    sysVersion,
+    rCmd,
+    removeAnyContainStr,
+    sleep,
+    normalize_args,
+    register_command,
+)
+
+
+from .tao_device import DevOp
+
+
+class asrTuningFile:
+    def __init__(self, inFile, outFile=None):
+        if not fileExist(inFile):
+            raise fileExceptionNotFound(f"文件不存在: {inFile}")
+
+        self.inFile = inFile
+        self.outFile = inFile if outFile is None else outFile
+        self.asrHeaderType = 1
+        self.asrTuningType = 2
+
+        self.fileType = 0
+        self.tuningFileLines = list()
+        self.tuningFileRemoveInfoLines = list()
+        self.headerFileLines = list()
+
+        self.fileType = self.checkASRFile()
+        if self.fileType == 0:
+            raise fileExceptionillegal(f"{inFile} 不是ASR文件或文件编码不是UTF-8")
+
+        self.readFile()
+
+    def checkASRFile(self):
+        try:
+            with open(self.inFile, "rt", encoding="utf-8", errors="replace") as f:
+                content = f.read()
+            if "//ASR" in content:
+                return self.asrHeaderType
+            elif "@@ASR" in content:
+                return self.asrTuningType
+            return 0
+        except UnicodeDecodeError:
+            loge(f"{self.inFile} is not UTF-8 encoded, please convert it to UTF-8 first")
+            return 0
+        except Exception as e:
+            loge(f"Error reading file {self.inFile}: {str(e)}")
+            return 0
+
+    def readFile(self):
+        with open(self.inFile, "r") as fileObj:
+            if self.fileType == self.asrTuningType:
+                self.tuningFileLines = fileObj.readlines()
+            elif self.fileType == self.asrHeaderType:
+                self.headerFileLines = fileObj.readlines()
+            else:
+                loge(f"{self.inFile} is not ASR Tuning/Header File")
+
+    def tuning2Header(self):
+        dump = False
+        if self.fileType == self.asrTuningType:
+            linesTmp = self._removeInfo(self.tuningFileLines, dump)
+            linesTmp = self._removeIsolatedBrace(linesTmp, dump)
+            linesTmp = self._comentAT(linesTmp, dump)
+            linesTmp = self._removeLinesBetweenMarkers(linesTmp, "//CDebugFirmwareFilter", "//", dump)
+            linesTmp = self._removeLinesBetweenMarkers(linesTmp, "//CFrameInfoFilter", "//", dump)
+            linesTmp = self._commentNullFilter(linesTmp, dump)
+            self.headerFileLines = self._dblcBracketsProcess(linesTmp, dump, tuning2cFlag=True)
+            logd(f"{self.inFile} tuning2Header done")
+            return True
+        logw(f"{self.inFile} is not ASR Tuning File")
+        return False
+
+    def header2Tuning(self):
+        dump = False
+        if self.fileType == self.asrHeaderType:
+            linesTmp = self._formatHeader(self.headerFileLines, dump)
+            linesTmp = self._replaceSymbol_1(linesTmp, dump)
+            self.tuningFileLines = self._dblcBracketsProcess(linesTmp, dump, tuning2cFlag=False)
+            logd(f"{self.inFile} header2Tuning done")
+            return True
+        logw(f"{self.inFile} is not ASR Header File")
+        return False
+
+    def _tuningRemoveReadOnly(self):
+        linesAfterRemoveInfo = self._removeInfo(self.tuningFileLines)
+        linesAfterRemoveMarker1 = self._removeLinesBetweenMarkers(linesAfterRemoveInfo, "@@CDebugFirmwareFilter", "@@")
+        linesAfterRemoveMarker2 = self._removeLinesBetweenMarkers(linesAfterRemoveMarker1, "@@CFrameInfoFilter", "@@")
+        self.tuningFileRemoveInfoLines = self._removeIsolatedBrace(linesAfterRemoveMarker2)
+        logd(f"{self.inFile} remove info done")
+
+    def lines2File(self, lines: list, fileName: str):
+        with open(fileName, "wt+", encoding="utf-8") as file:
+            logd(f"write {fileName}")
+            file.writelines(lines)
+
+    def saveTuningFile(self, out=None, withInfo=True):
+        if out is not None:
+            self.outFile = out
+
+        if withInfo:
+            self.lines2File(self.tuningFileLines, self.outFile)
+        else:
+            self.lines2File(self.tuningFileRemoveInfoLines, self.outFile)
+
+    def saveHeaderFile(self, out=None):
+        if out is not None:
+            self.outFile = out
+        self.lines2File(self.headerFileLines, self.outFile)
+
+    def _formatHeader(self, linelist, dump=False):
+        skip = 0
+        delete_space = 0
+        sde_setting = 0
+        caf_setting = 0
+        tmpLines = []
+        total_line = len(linelist)
+
+        SDE_KEYWORD = "CSpecialEffect"
+        CAF_KEYWORD = "CAFFilter"
+        SDE_PATTERNS = [
+            ("m_bManualMode_0", 2, 8),
+            ("m_bManualMode_1", 2, 8),
+            ("m_bManualMode_2", 2, 8),
+            ("m_bManualMode_3", 2, 8),
+            ("m_bManualMode_4", 2, 8),
+            ("m_bManualMode_5", 2, 8),
+            ("m_nLuxLUT", 2, 0),
+        ]
+        CAF_PATTERNS = [("m_pPDShiftPositionLUT_0_0", 1, 4), ("m_bCAFForce", 1, 0)]
+
+        for i in range(total_line):
+            if skip > 1:
+                skip -= 1
+                continue
+
+            current_line = linelist[i]
+            start_index = current_line.find("//")
+
+            if start_index >= 0:
+                str_line = current_line[start_index + 2 :]
+                tmpLines.append("@@" + str_line)
+                sde_setting = 1 if SDE_KEYWORD in str_line else 0
+                caf_setting = 1 if CAF_KEYWORD in str_line else 0
+            elif i >= (total_line - 2):
+                tmpLines.append(current_line)
+            else:
+                skip = 0
+                if sde_setting == 1 and i + 2 < total_line:
+                    next_line = linelist[i + 2]
+                    for pattern, skip_count, del_space in SDE_PATTERNS:
+                        if pattern in next_line:
+                            skip = skip_count
+                            delete_space = del_space
+                            break
+
+                if caf_setting == 1 and skip == 0 and i + 1 < total_line:
+                    next_line = linelist[i + 1]
+                    for pattern, skip_count, del_space in CAF_PATTERNS:
+                        if pattern in next_line:
+                            skip = skip_count
+                            delete_space = del_space
+                            break
+
+                if skip == 0:
+                    if delete_space == 0:
+                        tmpLines.append(current_line)
+                    else:
+                        tmpLines.append(current_line[delete_space:])
+        if dump:
+            self.lines2File(tmpLines, sys._getframe(0).f_code.co_name + ".data")
+        return tmpLines
+
+    def _removeInfo(self, lines, dump=False):
+        delLines = self._getDeleteLines(lines)
+        linesAfterDelete = self._deleteLineByNumber(lines, delLines)
+        linesAfterDelComma = self._delComma(linesAfterDelete)
+        if dump:
+            self.lines2File(linesAfterDelComma, sys._getframe(0).f_code.co_name + ".data")
+        return linesAfterDelComma
+
+    def _getDeleteLines(self, lines):
+        delLines = []
+        keyword = "fw_info"
+        keyword1 = "hw_info"
+        pattern = re.compile(r"Size: (\d+)x(\d+)")
+        count = 0
+        for i, line in enumerate(lines):
+            if "m_nRevisionNumber" not in line:
+                if keyword in line or keyword1 in line:
+                    rowSize = int(pattern.findall(line)[0][0])
+                    columnSize = int(pattern.findall(line)[0][1])
+                    if rowSize == 1 and columnSize == 1:
+                        for j in range(rowSize + 2):
+                            delLines.append(i + j + 1)
+                    elif rowSize == 1 and columnSize != 1:
+                        count = 1
+                    else:
+                        count = rowSize + 1
+                if count != 0:
+                    delLines.append(i + 1)
+                    if "}" in line:
+                        count -= 1
+        return delLines
+
+    def _deleteLineByNumber(self, lines, delLines):
+        delLines_sorted = sorted(delLines, reverse=True)
+        for line_number in delLines_sorted:
+            if line_number < len(lines):
+                del lines[line_number - 1]
+            else:
+                logw(f"行号 {line_number} 超出了文件行数")
+        return lines
+
+    def _stringToList(self, file_content):
+        lines = re.split(r"(\r\n|\n|\r)", file_content)
+        result = []
+        i = 0
+        while i < len(lines):
+            if i + 1 < len(lines) and lines[i + 1] in ["\n", "\r", "\r\n"]:
+                result.append(lines[i] + lines[i + 1])
+                i += 2
+            else:
+                if lines[i]:
+                    result.append(lines[i])
+                i += 1
+        return result
+
+    def _delComma(self, lines):
+        text = "".join(lines)
+        pattern = r",(?=\n\})"
+        cleaned_text = re.sub(pattern, "", text, flags=re.DOTALL)
+        return self._stringToList(cleaned_text)
+
+    def _isSdeOrCaf(self, str_line, writeLineNum):
+        writeLineNum += 1
+        find_name = "CSpecialEffect"
+        sde_setting = 1 if str_line.find(find_name) >= 0 else 0
+        find_name = "CAFFilter"
+        caf_setting = 1 if str_line.find(find_name) >= 0 else 0
+        return sde_setting, caf_setting
+
+    def _checkFileLegal(self, lines, judgeStr: str, judgeStr2: str):
+        text = "".join(lines)
+        return judgeStr in text or judgeStr2 in text
+
+    def _removeLinesBetweenMarkers(self, lines, start_marker, end_marker, dump=False):
+        tmpLines = []
+        skip = False
+        for line in lines:
+            if start_marker in line:
+                skip = True
+            elif end_marker in line:
+                skip = False
+                tmpLines.append(line)
+            elif not skip:
+                tmpLines.append(line)
+        if dump:
+            self.lines2File(tmpLines, sys._getframe(0).f_code.co_name + ".data")
+        return tmpLines
+
+    def _commentNullFilter(self, lines, dump=False):
+        tmpLines = []
+        i = 0
+        while i < len(lines):
+            current_line = lines[i].strip()
+            if current_line == "{" and i + 1 < len(lines) and lines[i + 1].strip() == "},":
+                tmpLines.append("//" + lines[i])
+                tmpLines.append("//" + lines[i + 1])
+                i += 2
+            else:
+                tmpLines.append(lines[i])
+                i += 1
+        if dump:
+            self.lines2File(tmpLines, sys._getframe(0).f_code.co_name + ".data")
+        return tmpLines
+
+    def replace_first_nth_line_after_string(self, lines, search_string, n, new_content):
+        for i, line in enumerate(lines):
+            if search_string in line:
+                target_line = i + n
+                if 0 <= target_line < len(lines):
+                    logd(f"成功在第 {i + 1} 行找到 '{search_string}'，并替换第 {target_line + 1} 行的内容")
+                    lines[target_line] = new_content + "\n" if not new_content.endswith("\n") else new_content
+        return lines
+
+    def _dblcBracketsProcess(self, lines, dump=False, tuning2cFlag=True):
+        if not self._checkFileLegal(lines, "@@CDBLCFirmwareFilter", "//CDBLCFirmwareFilter"):
+            logd(f"{self.inFile} 不存在 CDBLCFirmwareFilter")
+            return lines
+
+        if tuning2cFlag:
+            lines = self.replace_first_nth_line_after_string(lines, "m_pGridR", 2, "    {{\n")
+            lines = self.replace_first_nth_line_after_string(lines, "m_pGridB", 51, "    }}\n")
+        else:
+            lines = self.replace_first_nth_line_after_string(lines, "m_pGridR", 2, "    {\n")
+            lines = self.replace_first_nth_line_after_string(lines, "m_pGridB", 51, "    }\n")
+        logd("_dblcBracketsProcess done")
+        if dump:
+            self.lines2File(lines, sys._getframe(0).f_code.co_name + ".data")
+        return lines
+
+    def _comentAT(self, lines, dump=False):
+        writeLineNum = 0
+        postfix_str = ""
+        str_space = ""
+        sde_setting = 0
+        caf_setting = 0
+        linesComentAT = []
+
+        for line in lines:
+            start_index = line.find("@@")
+            if start_index >= 0:
+                line_str = line[start_index + 2 :]
+                linesComentAT.append(postfix_str + "//" + line_str)
+                sde_setting, caf_setting = self._isSdeOrCaf(line_str, writeLineNum)
+            else:
+                if sde_setting == 1:
+                    if line.find("m_bManualMode_0") >= 0:
+                        linesComentAT.append(postfix_str + "    {\n")
+                        linesComentAT.append(postfix_str + "        {\n")
+                        writeLineNum += 2
+                        str_space = "        "
+                    elif (
+                        line.find("m_bManualMode_1") >= 0
+                        or line.find("m_bManualMode_2") >= 0
+                        or line.find("m_bManualMode_3") >= 0
+                        or line.find("m_bManualMode_4") >= 0
+                        or line.find("m_bManualMode_5") >= 0
+                    ):
+                        linesComentAT.append(postfix_str + "        },\n")
+                        linesComentAT.append(postfix_str + "        {\n")
+                        writeLineNum += 2
+                    elif line.find("m_nLuxLUT") >= 0:
+                        linesComentAT.append(postfix_str + "        },\n")
+                        linesComentAT.append(postfix_str + "    },\n")
+                        writeLineNum += 2
+                        str_space = ""
+
+                if caf_setting == 1:
+                    if line.find("m_pPDShiftPositionLUT_0_0") >= 0:
+                        linesComentAT.append(postfix_str + "    {\n")
+                        writeLineNum += 1
+                        str_space = "    "
+                    elif line.find("m_bCAFForce") >= 0:
+                        linesComentAT.append(postfix_str + "    },\n")
+                        writeLineNum += 1
+                        str_space = ""
+
+                if line == "\n" or line == "\r\n":
+                    linesComentAT.append(str_space + line)
+                else:
+                    linesComentAT.append((postfix_str + str_space + line).encode("utf-8").decode("latin1"))
+                writeLineNum += 1
+        if dump:
+            self.lines2File(linesComentAT, sys._getframe(0).f_code.co_name + ".data")
+        return linesComentAT
+
+    def _replaceSymbol_1(self, lines, dump=False):
+        i = 0
+        while i < len(lines):
+            current_line = lines[i].strip()
+            if current_line == "@@{":
+                lines[i] = "{\n"
+            elif current_line == "@@},":
+                lines[i] = "},\n"
+            i += 1
+        if dump:
+            self.lines2File(lines, sys._getframe(0).f_code.co_name + ".data")
+        return lines
+
+    def _removeIsolatedBrace(self, lines, dump=False):
+        open_brace_stack = []
+        lines_to_delete = set()
+
+        for line_num, line in enumerate(lines):
+            stripped_line = line.strip()
+            if stripped_line == "{":
+                open_brace_stack.append(line_num)
+            elif stripped_line == "},":
+                if open_brace_stack:
+                    matching_open_brace_line = open_brace_stack.pop()
+                    lines_between = lines[matching_open_brace_line + 1 : line_num]
+                    all_lines_blank = all(l.strip() == "" for l in lines_between)
+
+                    if all_lines_blank:
+                        lines_to_delete.add(matching_open_brace_line)
+                        lines_to_delete.add(line_num)
+                        for i in range(matching_open_brace_line + 1, line_num):
+                            if lines[i].strip() == "":
+                                lines_to_delete.add(i)
+            else:
+                if stripped_line != "":
+                    open_brace_stack.clear()
+
+        tmpLines = [line for i, line in enumerate(lines) if i not in lines_to_delete]
+        if dump:
+            self.lines2File(tmpLines, sys._getframe(0).f_code.co_name + ".data")
+        return tmpLines
+
+
+def getFilePureName(filepath: str) -> Tuple[Path, str, str, str]:
+    """使用 pathlib 获取文件信息"""
+    path = Path(filepath)
+    if not path.is_file():
+        raise FileNotFoundError(f"{filepath} 不是一个有效的文件")
+
+    folder, nameWithSuffix, nameWithoutSuffix, suffix = path.parent, path.name, path.stem, path.suffix
+
+    return folder, nameWithSuffix, nameWithoutSuffix, suffix
+
+
+def checkFileNameIsTuning(file):
+    if os.path.isfile(file):
+        tuningFileFlagList = ["_isp", "_ipe", "_vfe", "_vbe", "_cpp"]
+        for i in tuningFileFlagList:
+            if i in file:
+                return True
+        logw(f"{file} not contain any of the following strings : {tuningFileFlagList}")
+        return False
+
+
+def getTuningFileEndStr(replaceStr, file, isTuning2c=True):
+    tuningFileFlagList = ["_isp", "_ipe", "_vfe", "_vbe", "_cpp"]
+    splitFlag = ""
+    if os.path.isfile(file):
+        for i in tuningFileFlagList:
+            if i in file:
+                splitFlag = i
+                break
+        if splitFlag == "":
+            loge(f"{file} not contain any of the following strings : {tuningFileFlagList}")
+            return None
+        path = os.path.split(file)[0]
+        nameWithSuffix = os.path.split(file)[1]
+        if isTuning2c:
+            targetFileName = nameWithSuffix.split(splitFlag)[-1].split(".")[0] + ".h"
+        else:
+            targetFileName = nameWithSuffix.split(splitFlag)[-1].split(".")[0] + ".data"
+        return os.path.join(path, replaceStr + splitFlag + targetFileName)
+    loge(f"{file} isn't a file")
+    return None
+
+
+def _fileProcessTuning2c(inFile, outFile=None):
+    if os.path.isfile(inFile):
+        if outFile is None:
+            folder, _, nameWithoutSuffix, _ = getFilePureName(inFile)
+            if nameWithoutSuffix is None:
+                return ErrCode.FILE_ILLEGAL
+            else:
+                outFile = os.path.join(folder, nameWithoutSuffix + ".h")
+        try:
+            asrTuning = asrTuningFile(inFile)
+            if not asrTuning.tuning2Header():
+                return ErrCode.FILE_ILLEGAL
+            asrTuning.saveHeaderFile(outFile)
+            logi(f"process {inFile} to {outFile} done")
+            return 0
+        except fileExceptionNotFound:
+            return ErrCode.FILE_NOT_FOUND
+        except fileExceptionillegal:
+            return ErrCode.FILE_ILLEGAL
+    loge(f"{inFile} isn't a file")
+    return ErrCode.FILE_ILLEGAL
+
+
+def _fileProcessC2Tuning(inFile, outFile=None):
+    if os.path.isfile(inFile):
+        if outFile is None:
+            path, _, nameWithoutSuffix, _ = getFilePureName(inFile)
+            outFile = os.path.join(path, nameWithoutSuffix + ".data")
+        try:
+            asrTuning = asrTuningFile(inFile)
+            if not asrTuning.header2Tuning():
+                return ErrCode.FILE_ILLEGAL
+            asrTuning.saveTuningFile(outFile)
+            logi(f"process {inFile} to {outFile} done")
+            return 0
+        except fileExceptionNotFound:
+            return ErrCode.FILE_NOT_FOUND
+        except fileExceptionillegal:
+            return ErrCode.FILE_ILLEGAL
+    loge(f"{inFile} isn't a file")
+    return ErrCode.FILE_ILLEGAL
+
+
+def _fileProcessTuningRemoveInfo(inFile, outFile=None):
+    logi(f"remove fw_info from {inFile}")
+    if outFile is None:
+        outFile = inFile
+    try:
+        asrTuning = asrTuningFile(inFile, outFile)
+        asrTuning._tuningRemoveReadOnly()
+        asrTuning.saveTuningFile(outFile, False)
+        return 0
+    except fileExceptionNotFound:
+        return ErrCode.FILE_NOT_FOUND
+    except fileExceptionillegal:
+        return ErrCode.FILE_ILLEGAL
+
+
+class asrCamOp(DevOp):
+    def __init__(self, checkCam=False, useUi=False, **kwargs):
+        logd(f"needroot = {kwargs.get('needRoot', False)}, serial = {kwargs.get('serial', '')}")
+        super().__init__(**kwargs)
+        if sysVersion == "Linux":
+            self.tuning_assistant = "tuning_assistant64.out"
+        elif sysVersion == "Windows":
+            self.tuning_assistant = "tuning_assistant64.exe"
+        self.soc = self.getASRDevice()
+        self.lcdOnAndUnlock()
+        self.tcpForward()
+        if checkCam:
+            self.checkCameraOpened()
+        self.facing = "rear_primary"
+        if useUi:
+            try:
+                if u2 is None:
+                    raise RuntimeError("uiautomator2 not installed")
+                if self.serial == None:
+                    exit("no device detected")
+                else:
+                    self.uiDev = u2.connect(self.serial)
+                self.lang = self.get_system_language()
+            except Exception as e:
+                logw(f"Failed to connect UI device: {e}")
+        self.resourceId = "com.asrmicro.camera:id/mode_list_item_text"
+        self.className = "android.widget.TextView"
+
+    def get_system_language(self):
+        locale = self.uiDev.shell("getprop persist.sys.locale").output.strip()
+        if locale.startswith("zh"):
+            return "zh"
+        if locale.startswith("en"):
+            return "en"
+        lang = self.uiDev.shell("getprop persist.sys.language").output.strip()
+        return lang
+
+    def uiUsage(self):
+        self.uiDev(resourceId=self.resourceId).click()
+        self.uiDev(resourceId=self.resourceId, text="Video").click()
+        self.uiDev(textContains="Video").click()
+        self.uiDev(resourceId=self.resourceId, description="目标元素").click()
+        self.uiDev(resourceId=self.resourceId, className="android.widget.TextView").click()
+        self.uiDev(resourceId=self.resourceId, instance=2).click()
+        self.uiDev(xpath="(//*[@resource-id=self.resourceId])[2]").click()
+        self.uiDev(scrollable=True).scroll.to(text="目标元素")
+
+    def uiClick(self, textList, slp=2, timeOut=2):
+        clicked = False
+        if self.lang == "zh":
+            textList = textList[::-1]
+        for t in textList:
+            if self.uiDev(text=t).exists(timeout=1):
+                self.uiDev(resourceId=self.resourceId, text=t).click(timeOut)
+                sleep(slp)
+                clicked = True
+                break
+        if not clicked:
+            loge(f"错误：未找到包含 {textList} 的元素")
+
+    def tuningGetModuleGroup(self):
+        rCmd(f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 3000 gm", 1, showCmd=True, showRet=False, logLevel="debug")
+
+    def tcpForward(self):
+        rCmd(
+            f'adb -s {self.serial} shell "settings put system screen_off_timeout 7200000"',
+            1,
+            showCmd=True,
+            logLevel="debug",
+        )
+        rCmd(
+            f"adb -s {self.serial} forward tcp:12218 localabstract:camera_tuning_server",
+            1,
+            showCmd=True,
+            logLevel="debug",
+        )
+        self.tuningGetModuleGroup()
+
+    def tcpRemove(self):
+        rCmd(f"adb -s {self.serial} kill-server", 1)
+
+    def resetNet(self):
+        rCmd("netsh interface portproxy delete v4tov4 listenport=12218", showCmd=True)
+
+    def netCon(self, on=True):
+        if on:
+            logi("ip connect on")
+            if sysVersion == "Linux":
+                rCmd(
+                    "echo AAbbcc123 |sudo -S sysctl -w net.ipv4.conf.enp3s0.route_localnet=1",
+                    showCmd=True,
+                    timeOut=30,
+                    shell=True,
+                    splitCmd=False,
+                )
+                rCmd(
+                    "echo AAbbcc123 |sudo -S iptables -t nat -F PREROUTING ",
+                    showRet=True,
+                    showCmd=True,
+                    shell=True,
+                    splitCmd=False,
+                )
+                rCmd(
+                    "echo AAbbcc123 |sudo -S iptables -t nat -A PREROUTING -p tcp --dport 12218 -j DNAT --to 127.0.0.1:10000 ",
+                    showRet=True,
+                    showCmd=True,
+                    shell=True,
+                    splitCmd=False,
+                )
+                rCmd(
+                    f"adb -s {self.serial} forward tcp:10000 localabstract:camera_tuning_server",
+                    showRet=False,
+                    showCmd=True,
+                    logLevel="info",
+                )
+                out = rCmd("ifconfig")[0]
+                ip = out.split("\n")[1].strip().split(" ")[1]
+                logi(f"{ip} : 12218")
+            elif sysVersion == "Windows":
+                loge("windows unsupport")
+                return
+            else:
+                loge(f"unsupport cmd in {sysVersion}")
+                return
+        else:
+            logi("ip connect off")
+            if sysVersion == "Linux":
+                rCmd(
+                    "sudo iptables -t nat -F PREROUTING ",
+                    showRet=True,
+                    showCmd=True,
+                    timeOut=30,
+                    shell=True,
+                    splitCmd=False,
+                )
+                rCmd(f"adb -s {self.serial} forward --remove tcp:10000", showCmd=True, logLevel="info")
+            elif sysVersion == "Windows":
+                self.resetNet()
+                rCmd(f"adb -s {self.serial} forward --remove tcp:10000")
+                rCmd("netsh interface portproxy reset", showRet=False)
+            else:
+                loge(f"unsupport cmd in {sysVersion}")
+
+    def openCam(self, id=0):
+        if id == 0:
+            rCmd("adb shell am start -a android.media.action.STILL_IMAGE_CAMERA", 1)
+        else:
+            rCmd("adb shell am start -a android.media.action.STILL_IMAGE_CAMERA", 2)
+            sleep(1)
+            self.adbTap((600, 1400))
+        sleep(2)
+        self.tuningGetModuleGroup()
+
+    def readIsp(self, CFliter: str, param: str, row=0, col=0, is_float=False, showCmd=False, module=0, group=0):
+        if sysVersion == "Linux":
+            eExit("tuning_assistant not support linux")
+        cmd = f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 3000 r m{module}_g{group} {CFliter} {param} {row} {col}"
+        try:
+            out = rCmd(cmd, sleep_s=0.5, showCmd=showCmd, logLevel="info")[0].strip()
+            if row > 0 or col > 0:
+                cmdResult = re.split("[ \n,.]+", out)[2]
+            else:
+                cmdResult = re.split("[ .]+", out)[2]
+
+            if is_number(cmdResult):
+                if is_float:
+                    value_f = int(cmdResult)
+                    tmp = ctypes.c_int(value_f)
+                    result = ctypes.cast(ctypes.pointer(tmp), ctypes.POINTER(ctypes.c_float)).contents.value
+                    return float(result)
+                return float(cmdResult)
+            logCallErr(f"{cmd}, please check the command.")
+            return 0.0
+            # self.tcpRemove()
+            # raise Exception("cmd fail")
+        except Exception as e:
+            logCallErr(str(e))
+            return 0.0
+
+    def writeIsp(self, CFliter: str, param: str, row: int, col: int, value: Union[int, float], showCmd=False):
+        if sysVersion == "Linux":
+            eExit("tuning_assistant not support linux")
+        if isinstance(value, float):
+            cf = ctypes.c_float(value)
+            value = ctypes.cast(ctypes.pointer(cf), ctypes.POINTER(ctypes.c_int)).contents.value
+        cmd = f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 3000 w m0_g0 {CFliter} {param} {row} {col} {value}"
+        out, _error = rCmd(cmd, sleep_s=0.5, showCmd=showCmd, logLevel="info")
+        checkMsg(out, "error")
+        logd(f"{out} {_error}")
+
+    def writeI2c(
+        self, devId: int, devAddr: int, regAddr: int, regBit: int, valueBit: int, regValue: int, showCmd=False
+    ):
+        cmd = f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 3000 w i2c {hex(devId)} {hex(devAddr)} {regBit} {hex(regAddr)}  {valueBit} {hex(regValue)}"
+        _ = rCmd(cmd, 0.5, showCmd)
+
+    def startVideoPreview(self, facing=0):
+        self.keyHome()
+        cmd = f"adb -s {self.serial} shell am start -a android.media.action.VIDEO_CAMERA --ei android.intent.extras.CAMERA_FACING {facing}"
+        rCmd(cmd, 1)
+
+    def startPreview(self, facing=0):
+        self.keyHome()
+        cmd = f"adb -s {self.serial} shell am start -a android.media.action.STILL_IMAGE_CAMERA --ei android.intent.extras.CAMERA_FACING {facing}"
+        rCmd(cmd, 1)
+
+    def isVideoMode(self):
+        info, _ = rCmd(f"adb -s {self.serial} shell dumpsys media.camera", 0.5)
+        return "VIDEO_RECORD" in info
+
+    def getCameraFacing(self):
+        ret = True
+        if self.soc == "dove":
+            info, _ = rCmd(f"adb -s {self.serial} shell dumpsys media.camera")
+            rc = re.compile(r"Camera ID: (\d+),")
+            cameraFacing = rc.findall(info)[0]
+            if cameraFacing == "1":
+                self.facing = "front"
+            elif cameraFacing == "0":
+                self.facing = "rear_primary"
+            elif cameraFacing == "2":
+                self.facing = "rear_secondary"
+            elif "failed" in info:
+                loge("getCameraFacing failed, device need remount")
+                ret = False
+                return ret
+        elif self.soc in ["lark", "larkl", "larkpro"]:
+            cmd = f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 20000 gm"
+            info = rCmd(cmd, 0.5, True, logLevel="debug")[0].splitlines()[1]
+            logd(info)
+            if "failed" in info:
+                loge("getCameraFacing failed")
+                ret = False
+                return ret
+            if "ISP_Rear_" in info or "ISP_Front_" in info or "ISP_Aux_" in info:
+                self.facing = info.split(",")[3].split("ISP_")[1]
+            else:
+                self.facing = info.split(",")[3].split("ISP_Preview_")[1]
+        return ret
+
+    def pushVrf(self, path, id="rear_primary", renameVrf=False, ignoreTag=None, matchCase=True):
+        # id: rear_primary, front, rear_secondary
+        out = ""
+        if not os.path.exists(path):
+            loge(f"{path} not exist")
+            return
+        rCmd(f"adb -s {self.serial} shell rm vendor/etc/camera/*.vrf", showCmd=True, logLevel="info")
+        if self.soc == "dove":
+            vrfEndName = "_sensor.vrf"
+            out, _ = rCmd(f"adb -s {self.serial} push {path} vendor/etc/camera/{id}{vrfEndName}", showCmd=True, logLevel="info")
+        elif self.soc in ["lark", "larkl", "larkpro"]:
+            if os.path.isfile(path):
+                vrfEndName = "_sensor_0.vrf"
+                out, _ = rCmd(f"adb -s {self.serial} push {path} vendor/etc/camera/{id}{vrfEndName}", showCmd=True, logLevel="info")
+            elif os.path.isdir(path):
+                index = 0
+                vrfFiles = findFilesWithSuffix(path, ".vrf")
+                if ignoreTag is not None:
+                    for tag in ignoreTag:
+                        vrfFiles = removeAnyContainStr(tag, vrfFiles, matchCase)
+                vrfFiles.sort(key=lambda x: x.split("_")[0])
+                for vrf in vrfFiles:
+                    target = f"{id}_sensor_{index}.vrf"
+                    if renameVrf:
+                        out, _ = rCmd(f"adb -s {self.serial} push {os.path.join(path, vrf)} vendor/etc/camera/{target}", showCmd=True, logLevel="info")
+                    else:
+                        out, _ = rCmd(f"adb -s {self.serial} push {os.path.join(path, vrf)} vendor/etc/camera/{vrf}", showCmd=True, logLevel="info")
+                    index += 1
+        if "Read-only" in out:
+            eExit("device is Read-only, may need remount")
+        rCmd("adb shell am start -a android.media.action.STILL_IMAGE_CAMERA")
+        sleep(2)
+        self.tuningGetModuleGroup()
+
+    def pushTuningFile(self, fullName):
+        if not os.path.exists(fullName):
+            loge(f"{fullName} not exist")
+            return
+        if "asr_" in fullName:
+            targetFile = os.path.split(fullName)[1].split("asr_")[1]
+        else:
+            targetFile = os.path.split(fullName)[1]
+        self.pushFile(fullName, f"vendor/etc/camera/tuning_files/{targetFile}")
+
+    def saveTuningFile(self, outPath, file, paramlist, delInfo):
+        module = "m" + paramlist[0] + "_g" + paramlist[2]
+        outFile = os.path.join(outPath, file.lower())
+        cmd = f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 20000 s {module} {outFile}"
+        out, _ = rCmd(cmd, 0.5, False)
+        if "failed" in out:
+            loge(f"{cmd} error")
+            return
+        if delInfo:
+            _fileProcessTuningRemoveInfo(outFile, outFile)
+        logi(f"save {module} {outFile} successful")
+
+    def saveDoveTuning(self, outPath, paramlist, mode, delInfo=True):
+        createFolder(outPath)
+        for i in range(len(paramlist)):
+            if mode == "video":
+                if paramlist[i][1] == "isp":
+                    file = self.facing + "_isp_setting_video.data"
+                    self.saveTuningFile(outPath, file, paramlist[i], delInfo)
+                if "preview" in paramlist[i][3] and paramlist[i][1] == "cpp":
+                    file = self.facing + "_cpp_video_setting.data"
+                    self.saveTuningFile(outPath, file, paramlist[i], delInfo)
+            elif mode == "preview":
+                if paramlist[i][1] == "isp":
+                    file = self.facing + "_isp_setting.data"
+                    self.saveTuningFile(outPath, file, paramlist[i], delInfo)
+                    continue
+                file = ""
+                if "preview" in paramlist[i][3] and paramlist[i][1] == "cpp":
+                    file = self.facing + "_cpp_preview_setting.data"
+                if "snapshot" in paramlist[i][3] and paramlist[i][1] == "cpp":
+                    file = self.facing + "_cpp_snapshot_setting.data"
+                if "nightshot" in paramlist[i][3] and paramlist[i][1] == "cpp":
+                    file = self.facing + "_cpp_nightshot_setting.data"
+                if file:
+                    self.saveTuningFile(outPath, file, paramlist[i], delInfo)
+
+    def saveDoveLiteTuning(self, outPath, paramlist, mode, delInfo=True):
+        createFolder(outPath)
+        for i in range(len(paramlist)):
+            file = ""
+            if mode == "video":
+                if paramlist[i][1] == "vfe":
+                    file = self.facing + "_vfe_setting.data"
+                elif paramlist[i][1] == "vbe":
+                    file = self.facing + "_vbe_setting.data"
+                elif paramlist[i][1] == "cpp" and "preview" in paramlist[i][3]:
+                    file = self.facing + "_cpp_video.data"
+                if file:
+                    self.saveTuningFile(outPath, file, paramlist[i], delInfo)
+            elif mode == "preview":
+                if paramlist[i][1] == "vfe":
+                    file = self.facing + "_vfe_setting.data"
+                elif paramlist[i][1] == "vbe":
+                    file = self.facing + "_vbe_setting.data"
+                elif paramlist[i][1] == "cpp" and "preview" in paramlist[i][3]:
+                    file = self.facing + "_cpp_preview.data"
+                elif paramlist[i][1] == "cpp" and "preview" in paramlist[i][3]:
+                    file = self.facing + "_cpp_snapshot.data"
+                if file:
+                    self.saveTuningFile(outPath, file, paramlist[i], delInfo)
+
+    def saveLarkTuning(self, outPath, paramlist, mode, delInfo=True):
+        createFolder(outPath)
+        for i in range(len(paramlist)):
+            file = ""
+            if mode == "video":
+                if paramlist[i][1] == "isp":
+                    file = self.facing + "_isp_video.data"
+                    self.saveTuningFile(outPath, file, paramlist[i], delInfo)
+                if "ipe_video" in paramlist[i][3].lower() and paramlist[i][1] == "ipe":
+                    file = self.facing + "_ipe_video.data"
+                    self.saveTuningFile(outPath, file, paramlist[i], delInfo)
+                if "IPE_Preview" in paramlist[i][3] and paramlist[i][1] == "ipe":
+                    file = self.facing + "_ipe_video.data"
+                    self.saveTuningFile(outPath, file, paramlist[i], delInfo)
+            elif mode == "preview":
+                if paramlist[i][1] == "isp":
+                    file = self.facing + "_isp_preview.data"
+                    self.saveTuningFile(outPath, file, paramlist[i], delInfo)
+                    continue
+                if paramlist[i][1] == "ipe":
+                    if "Preview" in paramlist[i][3]:
+                        file = self.facing + "_ipe_preview.data"
+                    elif "Capture" in paramlist[i][3]:
+                        file = self.facing + "_ipe_snapshot.data"
+                    elif "Portrait" in paramlist[i][3]:
+                        file = self.facing + "_ipe_portrait.data"
+                    elif "Night" in paramlist[i][3]:
+                        file = self.facing + "_ipe_night.data"
+                    else:
+                        logw(f"need support {paramlist[i][3]}")
+                        return
+                if file:
+                    self.saveTuningFile(outPath, file, paramlist[i], delInfo)
+
+    def saveTuning(self, mode, delInfo=True, outPath="tuning_data"):
+        cmd = f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 20000 gm"
+        info = rCmd(cmd, 0.5, True, logLevel="debug")[0].splitlines()
+        for i in info:
+            logd(f"{i}")
+        paramlist = []
+        for i in info:
+            if "isp" in i or "ipe" in i or "cpp" in i or "vfe" in i or "vbe" in i:
+                paramlist.append(i.replace(" ", "").split(","))
+        logd(f"paramlist {paramlist}")
+        if self.soc == "dove":
+            self.saveDoveTuning(outPath, paramlist, mode, delInfo)
+        elif self.soc in ["lark", "larkl", "larkpro"]:
+            self.saveLarkTuning(outPath, paramlist, mode, delInfo)
+        elif self.soc == "dovelite":
+            self.saveDoveLiteTuning(outPath, paramlist, mode, delInfo)
+        else:
+            eExit(f"unsupport platform {self.soc}")
+
+    def setRawDump(self, on):
+        cmd = f"adb -s {self.serial} shell setprop persist.vendor.camera.enable.capturedump {on}"
+        rCmd(cmd, 0.5, checkErr=True)
+
+    def dumpVrf(self, outPath: str, vrfName: str):
+        cmd = f"{self.tuning_assistant} 127.0.0.1 t 3000 3000 3000 dr m0_g0 {outPath} 1"
+        out, _ = rCmd(cmd, 2)
+        keyword1 = "ID="
+        keyword2 = "\n"
+        match = re.search(f"{keyword1}(.*?){keyword2}", out)
+        if match:
+            dumpName = "dump_" + str(match.group(1)) + ".vrf"
+            fullpath = os.path.join(outPath, dumpName)
+            newfile = os.path.join(outPath, str(vrfName))
+            from .tao_common import renameFile
+
+            renameFile(newfile, fullpath)
+        else:
+            eExit("抓取vrf失败")
+
+    def capVRF(self, name="null"):
+        outPath = self.curPath
+        if name == "null":
+            logi(f"capture vrf without name to {outPath}")
+        else:
+            logi(f"capture {name}.vrf to {outPath}")
+        if self.androidVersion == "13":
+            vrfPath = r"/data/vendor_de/camera/"
+        elif self.androidVersion == "14":
+            vrfPath = r"/data/vendor/camera/"
+        else:
+            vrfPath = r"/data/vendor/camera/"
+        oldFileList = self.getSuffixList(vrfPath, "jpg", "jpeg", "vrf")
+        logd(oldFileList)
+        cmd = f"adb -s {self.serial} shell input keyevent 27"
+        rCmd(cmd, 0.5, True, logLevel="info")
+        sleep(3)
+
+        foundedVRF = False
+        foundedJPG = False
+        pulledNameList = []
+        max_attempts = 5
+        jpgIndex = None
+        for _ in range(max_attempts):
+            fileList = self.getSuffixList(vrfPath, "jpg", "jpeg", "vrf")
+            diffNameList = list(set(fileList) - set(oldFileList))
+            logd(diffNameList)
+            if diffNameList:
+                for file in diffNameList:
+                    if file.lower().endswith(".jpg") or file.lower().endswith(".jpeg"):
+                        foundedJPG = True
+                        if name == "null":
+                            cmd = f"adb -s {self.serial} pull {vrfPath}{file}"
+                        else:
+                            cmd = f"adb -s {self.serial} pull {vrfPath}{file} {name}.jpg"
+                        if file not in pulledNameList:
+                            rCmd(cmd, 0.5, True, logLevel="info")
+                            pulledNameList.append(file)
+                        try:
+                            jpgIndex = get_file_index("frameid_", "_", file)
+                        except Exception:
+                            jpgIndex = None
+                    if file.lower().endswith(".vrf"):
+                        if file.startswith("short") or file.startswith("normal") or file.startswith("long"):
+                            foundedVRF = True
+                            cmd = f"adb -s {self.serial} pull {vrfPath}{file}"
+                            if file not in pulledNameList:
+                                rCmd(cmd, 0.5, True, logLevel="info")
+                                pulledNameList.append(file)
+                        elif foundedJPG and jpgIndex is not None and str(jpgIndex) in file and not foundedVRF:
+                            foundedVRF = True
+                            if name == "null":
+                                cmd = f"adb -s {self.serial} pull {vrfPath}{file}"
+                            else:
+                                cmd = f"adb -s {self.serial} pull {vrfPath}{file} {name}.vrf"
+                            if file not in pulledNameList:
+                                rCmd(cmd, 0.5, True, checkErr=True, logLevel="info")
+                                pulledNameList.append(file)
+                if foundedVRF and foundedJPG:
+                    break
+            else:
+                sleep(2.0)
+        if not foundedVRF:
+            loge(f"capture {os.path.join(outPath, name)}.vrf failed, new vrf not found in {vrfPath} ")
+
+    def capVRFLark(self, name="null"):
+        outPath = self.curPath
+        if name == "null":
+            logi(f"capture vrf without name to {outPath}")
+        else:
+            logi(f"capture {name}.vrf to {outPath}")
+        if self.androidVersion == "13":
+            vrfPath = r"/data/vendor_de/camera/"
+        elif self.androidVersion == "14":
+            vrfPath = r"/data/vendor/camera/"
+        else:
+            vrfPath = r"/data/vendor/camera/"
+        oldFileList = self.getSuffixList(vrfPath, "jpg", "jpeg", "vrf")
+        logd(oldFileList)
+        cmd = f"adb -s {self.serial} shell input keyevent 27"
+        rCmd(cmd, 0.5, True, logLevel="info")
+        sleep(3)
+
+        foundedVRF = False
+        foundedJPG = False
+        pulledNameList = []
+        max_attempts = 1
+        totalVRFNum = 0
+        for _ in range(max_attempts):
+            fileList = self.getSuffixList(vrfPath, "jpg", "jpeg", "vrf")
+            diffNameList = list(set(fileList) - set(oldFileList))
+            logd(diffNameList)
+            if diffNameList:
+                for file in diffNameList:
+                    if file.lower().endswith(".jpg") or file.lower().endswith(".jpeg"):
+                        foundedJPG = True
+                        if name == "null":
+                            cmd = f"adb -s {self.serial} pull {vrfPath}{file}"
+                        else:
+                            cmd = f"adb -s {self.serial} pull {vrfPath}{file} {name}.jpg"
+                        if file not in pulledNameList:
+                            rCmd(cmd, 0.5, True, logLevel="info")
+                            pulledNameList.append(file)
+                            jpgIndex = get_file_index("frameid_", "_", file)
+                    if file.lower().endswith(".vrf"):
+                        foundedVRF = True
+                        if file not in pulledNameList:
+                            totalVRFNum += 1
+                            cmd = f"adb -s {self.serial} pull {vrfPath}{file}"
+                            rCmd(cmd, 0.5, True, checkErr=True, logLevel="info")
+                            pulledNameList.append(file)
+                            logi(f"{file}  {name}.vrf")
+                            if name != "null":
+                                shutil.move(file, f"{name}.vrf")
+                if foundedVRF and foundedJPG:
+                    break
+            else:
+                sleep(2.0)
+        if not foundedVRF:
+            loge(f"capture {os.path.join(outPath, name)}.vrf failed, new vrf not found in {vrfPath} ")
+
+
+def CLI_tuningRemoveInfo(argsList):
+    parser = argparse.ArgumentParser(prog="tuningRemoveInfo", description="移除tuning参数fw_info")
+    parser.add_argument("-p", "--path", required=True, help="tuning文件名或路径")
+    args = parser.parse_args(argsList)
+    inFile = args.path
+    if os.path.isfile(inFile):
+        _fileProcessTuningRemoveInfo(inFile)
+    elif os.path.isdir(inFile):
+        for f in os.listdir(inFile):
+            if f.endswith(".data"):
+                raw_name = os.path.join(inFile, f)
+                _fileProcessTuningRemoveInfo(raw_name)
+    else:
+        loge(f"{inFile} is not a valid file or directory")
+
+
+# def CLI_pushVrf(args):
+#     argsDict = {}
+#     if args:
+#         argsDict = parseArgs(" ".join(args))
+#     idx = argsDict.get("i", "0")
+#     rename = int(argsDict.get("r", 0))
+#     dev = asrCamOp()
+#     if os.path.exists(args[1]):
+#         dev.pushVrf(args[1], idx, rename)
+#     else:
+#         loge(f"cmd error, psvrf name.vrf/path [i=0,1,2]cameraId [r=0,1]renameVrf")
+
+
+def CLI_pushVrf(argsList):
+    parser = argparse.ArgumentParser(prog="pushvrf", description="push vrf到设备")
+    parser.add_argument("-p", "--path", required=True, help="vrf文件名或路径")
+    parser.add_argument(
+        "-i",
+        "--index",
+        default="rear_primary",
+        choices=["rear_primary", "front", "rear_secondary"],
+        help="push摄像头位置",
+    )
+    parser.add_argument("--no-rename", action="store_false", dest="rename", help="不将文件按filecam重命名")
+    parser.set_defaults(rename=True)
+    parser.add_argument(
+        "-t", "--tag", required=False, nargs="+", help="如果vrf包含tag(支持多tag), push时忽略包含tag列表中的文件"
+    )
+    parser.add_argument("--matchcase", action="store_true", dest="matchcase", help="是否区分tag大小写")
+    parser.set_defaults(matchcase=False)
+    args = parser.parse_args(argsList)
+
+    logi(
+        f"psvrf {args.path} indxe={args.index}, rename={args.rename}, ignoreTag={args.tag}, matchcase={args.matchcase}"
+    )
+
+    dev = asrCamOp()
+    if os.path.exists(args.path):
+        dev.pushVrf(args.path, args.index, args.rename, args.tag, args.matchcase)
+    else:
+        loge(f"cmd error, psvrf name.vrf/path [i=0,1,2]cameraId [r=0,1]renameVrf")
+
+
+def CLI_capVrf(argsList):
+    parser = argparse.ArgumentParser(prog="capvrf", description="抓取vrf")
+    parser.add_argument("-f", "--file", type=str, required=False, help="抓取vrf 文件名")
+    args = parser.parse_args(argsList)
+    asrCam = asrCamOp(True)
+    asrCam.setRawDump(1)
+    if args.file == None:
+        if asrCam.soc in ["lark", "larkl", "larkpro"]:
+            asrCam.capVRFLark()
+        else:
+            asrCam.capVRF()
+    else:
+        name = args.file
+        if asrCam.soc in ["lark", "larkl", "larkpro"]:
+            asrCam.capVRFLark(name)
+        else:
+            asrCam.capVRF(name)
+    asrCam.setRawDump(0)
+
+
+def CLI_saveTuning(argsList):
+    if sysVersion == "Linux":
+        loge("Linux not support save tuning!")
+        return
+    parser = argparse.ArgumentParser(prog="savetuning", description="保存tuning参数")
+    parser.add_argument("-a", "--all", type=str, default="1", choices=["0", "1"], help="是否保存包含RO的参数")
+    parser.add_argument("-p", "--path", type=str, default="tuning_data", help="保存文件夹名")
+    args = parser.parse_args(argsList)
+
+    path = args.path
+    previewIcon = ["Photo", "拍照"]
+    videoIcon = ["Video", "视频"]
+    asrCam = asrCamOp(True, True)
+    if asrCam.isVideoMode():
+        logi("current is video mode, switch to preview!")
+        asrCam.uiClick(previewIcon)
+    if not asrCam.getCameraFacing():
+        eExit("get camera ID failed")
+    if asrCam.soc in ["lark", "larkl", "larkpro"]:
+        try:
+            otpEn = asrCam.readIsp("CDigitalGainFirmwareFilter", "m_bWhiteBalanceOTPEnable")
+        except Exception as exc:
+            loge(str(exc))
+            otpEn = 0
+    else:
+        otpEn = 0
+    logh(f"otpEn {otpEn}")
+    if args.all == "1" or otpEn == 1:
+        logi(f"save tuning with debug information {asrCam.serial}")
+        asrCam.saveTuning("preview", False, path)
+        asrCam.uiClick(videoIcon)
+        asrCam.saveTuning("video", False, path)
+        asrCam.uiClick(previewIcon)
+    else:
+        logi(f"save tuning without debug information {asrCam.serial}")
+        asrCam.saveTuning("preview", True, path)
+        asrCam.uiClick(videoIcon)
+        asrCam.saveTuning("video", True, path)
+        asrCam.uiClick(previewIcon)
+
+
+def CLI_pushTuning(argsList):
+    parser = argparse.ArgumentParser(prog="pushtuning", description="push tuning参数")
+    parser.add_argument("-p", "--path", required=True, help="push tuning文件名或路径")
+    args = parser.parse_args(argsList)
+    inFile = args.path
+    asrCam = asrCamOp()
+    if os.path.isfile(inFile):
+        asrCam.pushTuningFile(inFile)
+    elif os.path.isdir(inFile):
+        for f in os.listdir(inFile):
+            if f.endswith(".data"):
+                raw_name = os.path.join(inFile, f)
+                asrCam.pushTuningFile(raw_name)
+    else:
+        loge(f"{inFile} is not a valid file or directory")
+
+
+def CLI_tuning2c(argsList):
+    parser = argparse.ArgumentParser(prog="tuning2c", description="tuning参数转 .h文件")
+    parser.add_argument("-p", "--path", required=True, help="tuning文件名或路径")
+    parser.add_argument("-s", "--prefix", required=False, help="转为头文件替换的前缀")
+    args = parser.parse_args(argsList)
+
+    sensorName = args.prefix
+    inFile = args.path
+    if os.path.isfile(inFile):
+        if sensorName == "":
+            _fileProcessTuning2c(inFile)
+        else:
+            if checkFileNameIsTuning(inFile):
+                outFile = getTuningFileEndStr(sensorName, inFile)
+                _fileProcessTuning2c(inFile, outFile)
+    elif os.path.isdir(inFile):
+        for f in os.listdir(inFile):
+            if f.endswith(".data"):
+                raw_name = os.path.join(inFile, f)
+                if sensorName == "":
+                    _fileProcessTuning2c(raw_name)
+                else:
+                    if checkFileNameIsTuning(raw_name):
+                        outFile = getTuningFileEndStr(sensorName, raw_name)
+                        _fileProcessTuning2c(raw_name, outFile)
+    else:
+        loge(f"{inFile} is not a valid file or directory")
+
+
+def CLI_c2tuning(argsList):
+    parser = argparse.ArgumentParser(prog="c2tuning", description="将 .h文件转为 tuning文件")
+    parser.add_argument("-p", "--path", required=True, help="tuning文件名或路径")
+    parser.add_argument("-s", "--prefix", required=False, help="转为头文件替换的前缀")
+    args = parser.parse_args(argsList)
+
+    sensorName = args.prefix
+    inFile = args.path
+    splitFlag = "asr_"
+    if os.path.isfile(inFile):
+        if sensorName == None:
+            _fileProcessC2Tuning(inFile)
+        else:
+            if splitFlag not in inFile:
+                loge(f"{inFile} not contain {splitFlag} flag")
+                return
+            if checkFileNameIsTuning(inFile):
+                outFile = getTuningFileEndStr(sensorName, inFile, False)
+                _fileProcessC2Tuning(inFile, outFile)
+    elif os.path.isdir(inFile):
+        for f in os.listdir(inFile):
+            if f.endswith(".h"):
+                raw_name = os.path.join(inFile, f)
+                if sensorName == None:
+                    _fileProcessC2Tuning(raw_name)
+                else:
+                    if splitFlag not in raw_name:
+                        loge(f"{raw_name} not contain {splitFlag} flag, skip")
+                        continue
+                    if checkFileNameIsTuning(raw_name):
+                        outFile = getTuningFileEndStr(sensorName, raw_name, False)
+                        _fileProcessC2Tuning(raw_name, outFile)
+    else:
+        loge(f"{inFile} is not a valid file or directory")
+
+
+def CLI_netCon(args):
+    dev = asrCamOp(True)
+    if len(args) == 0:
+        dev.netCon(True)
+    else:
+        dev.netCon(False)
+
+
+def CLI_osd(_args):
+    dev = DevOp()
+    osdAppPath = os.path.join(sys.path[0], "osd_usage", "osdApp.apk")
+    dev.adbCmd(f"install {osdAppPath}", False)
+    dev.adbCmd("setenforce 0")
+    dev.adbCmd("setprop persist.vendor.camera.osd.dump 1")
+    dev.adbCmd("touch /data/local/tmp/isp.txt")
+
+
+_COMMAND_REGISTRY = {}
+
+
+def printHelp():
+    print("[tuning]")
+    print("psvrf -h         :push vrf to vendor/etc/camera for filecam")
+    print("capvrf -h        :capture vrf in current path")
+    print("savetuning -h    :save current tuning data")
+    print("pushtuning -h    :push tuning data to vendor/etc/camera/tuning_files")
+    print("tuning2c -h      :convert tuning data to c header")
+    print("c2tuning -h      :convert c header to tuning data")
+    print("tuningr -h       :remove readonly info")
+    print("ipc {off}        :connect camera with ip address")
+    print("osd              :install osd app")
+
+
+CLI_pushVrf = register_command("psvrf", registry=_COMMAND_REGISTRY)(CLI_pushVrf)
+CLI_capVrf = register_command("capvrf", registry=_COMMAND_REGISTRY)(CLI_capVrf)
+CLI_saveTuning = register_command("savetuning", registry=_COMMAND_REGISTRY)(CLI_saveTuning)
+CLI_pushTuning = register_command("pushtuning", registry=_COMMAND_REGISTRY)(CLI_pushTuning)
+CLI_tuning2c = register_command("tuning2c", registry=_COMMAND_REGISTRY)(CLI_tuning2c)
+CLI_c2tuning = register_command("c2tuning", registry=_COMMAND_REGISTRY)(CLI_c2tuning)
+CLI_tuningRemoveInfo = register_command("tuningr", registry=_COMMAND_REGISTRY)(CLI_tuningRemoveInfo)
+CLI_netCon = register_command("ipc", registry=_COMMAND_REGISTRY)(CLI_netCon)
+CLI_osd = register_command("osd", registry=_COMMAND_REGISTRY)(CLI_osd)
+
+
+def tuningMain(args):
+    debugCtrl(1) if "debug" in args else debugCtrl(0)
+    args.remove("debug") if "debug" in args else args
+    args = normalize_args(args)
+    if len(args) < 1 or args[0] in {"help", "-h", "--help"}:
+        printHelp()
+        return
+    cmd = args[0]
+    handler = _COMMAND_REGISTRY.get(cmd)
+    if handler is None:
+        loge(f"unsupport command {cmd}")
+        return
+    handler(args[1:])
+
+
+if __name__ == "__main__":
+    debugCtrl(1) if "debug" in sys.argv else debugCtrl(0)
+    sys.argv.remove("debug") if "debug" in sys.argv else sys.argv
+    tuningMain(sys.argv)