diff --git a/.gitignore b/.gitignore index aa724b7..377e1a6 100644 --- a/.gitignore +++ b/.gitignore @@ -12,4 +12,5 @@ /captures .externalNativeBuild .cxx +.idea local.properties diff --git a/CMakeLists.txt b/CMakeLists.txt index 975bf74..1dd9080 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -26,6 +26,8 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Android") add_library(face_sdk SHARED app/src/main/cpp/main.cpp app/src/main/cpp/AndroidOut.cpp + app/src/main/cpp/DebugLog.h + app/src/main/cpp/DebugLog.cpp vulkan/AppBase.h vulkan/AppBase.cpp vulkan/Application.h diff --git a/DEBUG_GUIDE.md b/DEBUG_GUIDE.md new file mode 100644 index 0000000..d50a68e --- /dev/null +++ b/DEBUG_GUIDE.md @@ -0,0 +1,191 @@ +# Face SDK 崩溃调试指南 + +本文档说明如何配合 AI 定位 `libface_sdk.so` 里的崩溃 / 异常。核心思路：**把 Vulkan 每一次异常的上下文写进一个持久日志文件里，崩溃或画面卡住后把这份文件发给 AI 分析。** + +--- + +## 一、已经加好的东西（不需要你做什么） + +### 1. `DebugLog` 模块（`app/src/main/cpp/DebugLog.{h,cpp}`） + +- 线程安全； +- 每条日志带**时间戳 + 线程 ID（tid）**； +- 写到 App **私有目录下的文件** —— 不会被 logcat 自动清掉； +- 每写一行 `fflush`，进程挂了也不丢最后几行； +- 文件大小超过 2MB 自动滚动到 `.old`； +- 同步把日志镜像到 logcat，tag 是 `FACE_DBG`。 + +### 2. 打点位置 + +| 位置 | 打点内容 | 用途 | +|---|---|---| +| `android_main` 启动 | pid、tid、日志文件绝对路径 | 每次启动一条，作为分段锚点 | +| 渲染循环心跳 | 每 600 帧一条：`frame=X exceptions_so_far=Y` | 判断启动多久后崩溃 / 异常持续性 | +| `try/catch` 兜底 | 首 10 次异常每次都打，之后每 120 次打一次 | **Vulkan 异常不会再让进程硬崩**，留住现场 | +| `handle_cmd` | 每个 `APP_CMD_*` 事件（尤其 `INIT_WINDOW`/`TERM_WINDOW`/`CONFIG_CHANGED`） | 旋转 / 切后台 / 锁屏场景的时间线 | +| `FaceApp::initVulkan` 入/出口 | 调用次数、`_applicationInited` / `_faceAppInited` / `_sceondInited` 状态 | 判断是否被多次重复调用 | +| `processImageNative` / `passDataToNative` | 每 300 次调用打一条 tid | 验证"Java 两个回调在不同线程并发调 Vulkan"假设 | +| `Application::drawFrame` 里的 4 次 Vulkan 调用 | 非 `VK_SUCCESS` 时打印数值 + 字符串名（例如 `-4 (VK_ERROR_DEVICE_LOST)`） | **最关键的证据** | + +### 3. 关键行为变化 + +**⚠️ 现在 `drawFrame` 里 Vulkan 抛出的异常会被 `try/catch` 吃掉 —— App 不会再因为这类问题硬崩溃。** + +- 好处：你能继续跑、继续复现、日志一直在写； +- 代价：出问题时表现从"崩溃"变成"**画面卡住 / 黑屏 / 不再更新**"。 +- 如果想暂时回到硬崩行为：把 `app/src/main/cpp/main.cpp` 里那段 `try { g_Application->drawFrame(...); } catch (...) { ... }` 改回直接 `g_Application->drawFrame(frameTime);` 即可。 + +--- + +## 二、怎么把日志文件取出来 + +### 方式 A：`run-as`（推荐，不需要 root） + +```bash +adb shell "run-as com.inewme.uvmirror cat files/face_sdk_debug.log" > face_sdk_debug.log +adb shell "run-as com.inewme.uvmirror cat files/face_sdk_debug.log.old" > face_sdk_debug.log.old +``` + +> `.old` 只有文件滚动过一次才存在，没有可以忽略错误。 + +### 方式 B：直接看 logcat（实时） + +```bash +adb logcat -s FACE_DBG +``` + +和文件内容基本一致。跑较久的话还是文件更可靠。 + +### 方式 C：从 App 里拿路径 + +启动后 `FACE_DBG` 第一条日志长这样： + +``` +[10:12:03.041][tid=12345] android_main start, pid=23456 tid=12345, logPath=/data/user/0/com.inewme.uvmirror/files/face_sdk_debug.log +``` + +照这个路径走就对了。 + +--- + +## 三、你现在要做的事（B 方案：两种场景都复现一次） + +### 场景 1：旋转崩溃（已确认必现） + +1. 打开 App，等初始化完成（画面能看到人脸渲染）。 +2. **旋转一次屏幕**。 +3. 等 3~5 秒让日志写进去。 +4. 取 `face_sdk_debug.log`，**不要清文件**，继续场景 2。 + +期望看到的关键行： +``` +>> handle_cmd APP_CMD_TERM_WINDOW(...) +>> handle_cmd APP_CMD_INIT_WINDOW(...) +FaceApp::initVulkan enter, call#2 ... +drawFrame[NNN] vkAcquireNextImageKHR -> ??? (...) +!!! drawFrame std::exception (frame=NNN count=M): failed to ... +``` + +注意里面那个 `???` —— 这是整件事的核心证据。 + +### 场景 2：长时间运行崩溃（之前那个 10 分钟左右的） + +**不要退出 App，接着跑**。现在即使旋转触发了异常，进程没死，我们希望看后续会不会再出另一种 VkResult： + +1. 尽量不操作（不切后台、不旋转、不锁屏，让 App 持续渲染）。 +2. 连续跑 **15~20 分钟**，观察是否复现之前的"无外部事件崩溃"。 +3. 复现后（或稳定 20 分钟未复现也行），再取一次 `face_sdk_debug.log`（这次会覆盖场景 1 的那份，所以务必**先把场景 1 的单独保存好**）。 + +期望看到的关键行（如果真的是 DEVICE_LOST）： +``` +drawFrame[NNN] vkQueueSubmit -> -4 (VK_ERROR_DEVICE_LOST) ... +``` +或者某个 Vulkan 调用返回其他错误码。 + +### 辅助信息（手边有就顺便记一下） + +| 项 | 为什么要 | +|---|---| +| 机型 + Android 版本 | GPU 驱动差异；Adreno / Mali / Xclipse 表现差别大 | +| 复现时手机是不是很烫 | 排查 GPU 温控 / thermal throttling | +| 旋转时是"横屏 → 竖屏"还是"竖屏 → 横屏" / 多次连续旋转？ | 某些机型一次 vs 多次触发行为不同 | +| 10 分钟崩溃时 App 在做什么（有在切换 motion 吗？） | 帮助排除 `changeMotionList` 相关路径 | + +--- + +## 四、发给 AI 的时候包含什么 + +最小集： + +1. `face_sdk_debug.log`（场景 1 旋转那份） +2. `face_sdk_debug.log`（场景 2 长跑那份） +3. 如果文件很大，**完整发**比截断发强（AI 主要关心最后几千行） +4. 一句话说明这份日志对应场景 1 还是场景 2，是否复现了 + +不需要的： + +- logcat 完整 dump（体积太大且大多无关，除非 AI 主动问特定 tag） +- 录屏 +- 源代码（AI 已经能看到仓库） + +--- + +## 五、当前未解决的假设，等日志验证 + +| 假设 | 对应 VkResult | 修法 | +|---|---|---| +| 旋转导致 surface 失效未处理 | `VK_ERROR_OUT_OF_DATE_KHR` (-1000001004) 或 `VK_ERROR_SURFACE_LOST_KHR` (-1000000000) 或 `VK_SUBOPTIMAL_KHR` (1000001003) | 实现 `APP_CMD_TERM_WINDOW` 销毁流程 + swapchain 重建 | +| Java 多线程并发提交 graphicsQueue 导致 GPU 长时间后挂 | `VK_ERROR_DEVICE_LOST` (-4)，且 `processImageNative` / `passDataToNative` 日志里 tid 不同 | 给所有 `vkQueueSubmit`/`vkQueuePresentKHR` 加全局 queue mutex | +| 驱动 bug / 温度导致 GPU hang | `VK_ERROR_DEVICE_LOST` (-4)，单线程也出 | 捕获并尝试重建 device，或上报给机型厂商 | +| 资源累积泄漏 | `VK_ERROR_OUT_OF_DEVICE_MEMORY` (-2) 或 `VK_ERROR_TOO_MANY_OBJECTS` | 排查 `beginSingleTimeCommands`/`processWithVulkan` 路径 | + +--- + +## 六、日志样例（便于你确认打印是否正常） + +正常启动应该看到： +``` +========== DebugLog opened @ 2026-04-23 14:05:12 (pid=12345) ========== +[14:05:12.019][tid=12345] android_main start, pid=12345 tid=12345, logPath=/data/user/0/com.inewme.uvmirror/files/face_sdk_debug.log +[14:05:12.155][tid=12345] >> handle_cmd APP_CMD_START(10) tid=12345 +[14:05:12.155][tid=12345] << handle_cmd APP_CMD_START done +[14:05:12.210][tid=12345] >> handle_cmd APP_CMD_INIT_WINDOW(1) tid=12345 +[14:05:12.210][tid=12345] handle_cmd APP_CMD_INIT_WINDOW: calling initVulkan() +[14:05:12.210][tid=12345] FaceApp::initVulkan enter, call#1 _applicationInited=0 _faceAppInited=0 _secondfaceAppInited=0 +[14:05:13.420][tid=12345] FaceApp::initVulkan exit, call#1 _applicationInited=1 _faceAppInited=1 _secondfaceAppInited=1 +[14:05:13.420][tid=12345] handle_cmd APP_CMD_INIT_WINDOW: initVulkan() returned, isInited=1 +[14:05:13.421][tid=12345] << handle_cmd APP_CMD_INIT_WINDOW done +[14:05:14.005][tid=67890] processImageNative #1 tid=67890 w=480 h=480 +[14:05:14.008][tid=67891] passDataToNative #1 tid=67891 point_count=468 w=480 h=480 +[14:05:35.200][tid=12345] heartbeat: frame=600 exceptions_so_far=0 +``` + +旋转时如果触发异常应该看到： +``` +[14:06:10.112][tid=12345] >> handle_cmd APP_CMD_CONFIG_CHANGED(8) tid=12345 +[14:06:10.113][tid=12345] >> handle_cmd APP_CMD_TERM_WINDOW(2) tid=12345 +[14:06:10.113][tid=12345] handle_cmd APP_CMD_TERM_WINDOW: (no handler yet, ...) +[14:06:10.113][tid=12345] << handle_cmd APP_CMD_TERM_WINDOW done +[14:06:10.250][tid=12345] >> handle_cmd APP_CMD_INIT_WINDOW(1) tid=12345 +[14:06:10.250][tid=12345] FaceApp::initVulkan enter, call#2 _applicationInited=1 _faceAppInited=1 _secondfaceAppInited=0 +[14:06:10.250][tid=12345] FaceApp::initVulkan exit, call#2 _applicationInited=1 _faceAppInited=1 _secondfaceAppInited=1 +[14:06:10.280][tid=12345] drawFrame[1234] vkAcquireNextImageKHR -> -1000001004 (VK_ERROR_OUT_OF_DATE_KHR) currentFrame=0 +[14:06:10.280][tid=12345] !!! drawFrame std::exception (frame=1234 count=1): failed to acquire swap chain image! +``` + +**只要日志里能看到 `vkXxxKHR -> <数值> (<名字>)` 这一行，诊断就成立了。** + +--- + +## 七、文件清单（仅供参考，日常不用动） + +``` +app/src/main/cpp/ + DebugLog.h 新增 + DebugLog.cpp 新增 + main.cpp 改：日志初始化 / 心跳 / try-catch / cmd 日志 / JNI tid +vulkan/ + Application.cpp 改：drawFrame 4 处 VkResult 日志 + VkResultStr + FaceApp.cpp 改：initVulkan 入/出口日志 +CMakeLists.txt 改：加入 DebugLog.cpp 到 Android 构建 +``` diff --git a/app/src/main/cpp/DebugLog.cpp b/app/src/main/cpp/DebugLog.cpp new file mode 100644 index 0000000..0815aac --- /dev/null +++ b/app/src/main/cpp/DebugLog.cpp @@ -0,0 +1,98 @@ +#include "DebugLog.h" + +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace { + +std::mutex g_mtx; +FILE* g_fp = nullptr; +std::string g_path; +constexpr size_t kMaxSize = 2 * 1024 * 1024; // 2 MB before rotation + +pid_t currentTid() { + return static_cast(syscall(SYS_gettid)); +} + +} // namespace + +namespace DebugLog { + +void init(const char* internalDataPath) { + std::lock_guard lk(g_mtx); + if (g_fp) { + return; // already initialized + } + + const char* base = (internalDataPath && *internalDataPath) ? internalDataPath : "/data/local/tmp"; + g_path = std::string(base) + "/face_sdk_debug.log"; + + // Rotate once if current file is too large. + struct stat st{}; + if (stat(g_path.c_str(), &st) == 0 && static_cast(st.st_size) > kMaxSize) { + std::string backup = g_path + ".old"; + std::remove(backup.c_str()); + std::rename(g_path.c_str(), backup.c_str()); + } + + g_fp = std::fopen(g_path.c_str(), "a"); + if (g_fp) { + time_t now = time(nullptr); + struct tm tm_info{}; + localtime_r(&now, &tm_info); + char tbuf[64]; + strftime(tbuf, sizeof(tbuf), "%Y-%m-%d %H:%M:%S", &tm_info); + std::fprintf(g_fp, + "\n========== DebugLog opened @ %s (pid=%d) ==========\n", + tbuf, getpid()); + std::fflush(g_fp); + } + + __android_log_print(ANDROID_LOG_INFO, "FACE_DBG", + "DebugLog file path: %s", g_path.c_str()); +} + +void log(const char* fmt, ...) { + char buf[1024]; + va_list ap; + va_start(ap, fmt); + int n = std::vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + if (n < 0) return; + + pid_t tid = currentTid(); + + timespec ts{}; + clock_gettime(CLOCK_REALTIME, &ts); + struct tm tm_info{}; + localtime_r(&ts.tv_sec, &tm_info); + char timebuf[32]; + strftime(timebuf, sizeof(timebuf), "%H:%M:%S", &tm_info); + + std::lock_guard lk(g_mtx); + if (g_fp) { + std::fprintf(g_fp, "[%s.%03ld][tid=%d] %s\n", + timebuf, ts.tv_nsec / 1000000, tid, buf); + std::fflush(g_fp); + } + __android_log_print(ANDROID_LOG_INFO, "FACE_DBG", "[tid=%d] %s", tid, buf); +} + +void flush() { + std::lock_guard lk(g_mtx); + if (g_fp) std::fflush(g_fp); +} + +std::string getLogPath() { + std::lock_guard lk(g_mtx); + return g_path; +} + +} // namespace DebugLog diff --git a/app/src/main/cpp/DebugLog.h b/app/src/main/cpp/DebugLog.h new file mode 100644 index 0000000..49ce238 --- /dev/null +++ b/app/src/main/cpp/DebugLog.h @@ -0,0 +1,25 @@ +#ifndef FACE_SDK_DEBUGLOG_H +#define FACE_SDK_DEBUGLOG_H + +#include + +namespace DebugLog { + +// Call once (e.g. in android_main) with android_app->activity->internalDataPath. +// Safe to call multiple times; subsequent calls are no-ops. +void init(const char* internalDataPath); + +// Thread-safe. Also mirrored to logcat with tag "FACE_DBG". +// Every line is prefixed with timestamp + thread id and flushed to disk immediately, +// so even a hard crash will preserve the tail. +void log(const char* fmt, ...) __attribute__((format(printf, 1, 2))); + +// Force flush to disk. +void flush(); + +// Absolute path of the log file (valid after init()). +std::string getLogPath(); + +} // namespace DebugLog + +#endif // FACE_SDK_DEBUGLOG_H diff --git a/app/src/main/cpp/main.cpp b/app/src/main/cpp/main.cpp index 54d346b..88ce0cd 100644 --- a/app/src/main/cpp/main.cpp +++ b/app/src/main/cpp/main.cpp @@ -3,12 +3,43 @@ #include #include #include "AndroidOut.h" +#include "DebugLog.h" #include "FaceApp.h" #include +#include +#include +#include #include #include using namespace std; + +static inline pid_t dbg_tid() { + return static_cast(syscall(SYS_gettid)); +} + +static const char* appCmdName(int32_t cmd) { + switch (cmd) { + case APP_CMD_INPUT_CHANGED: return "APP_CMD_INPUT_CHANGED"; + case APP_CMD_INIT_WINDOW: return "APP_CMD_INIT_WINDOW"; + case APP_CMD_TERM_WINDOW: return "APP_CMD_TERM_WINDOW"; + case APP_CMD_WINDOW_RESIZED: return "APP_CMD_WINDOW_RESIZED"; + case APP_CMD_WINDOW_REDRAW_NEEDED: return "APP_CMD_WINDOW_REDRAW_NEEDED"; + case APP_CMD_CONTENT_RECT_CHANGED: return "APP_CMD_CONTENT_RECT_CHANGED"; + case APP_CMD_GAINED_FOCUS: return "APP_CMD_GAINED_FOCUS"; + case APP_CMD_LOST_FOCUS: return "APP_CMD_LOST_FOCUS"; + case APP_CMD_CONFIG_CHANGED: return "APP_CMD_CONFIG_CHANGED"; + case APP_CMD_LOW_MEMORY: return "APP_CMD_LOW_MEMORY"; + case APP_CMD_START: return "APP_CMD_START"; + case APP_CMD_RESUME: return "APP_CMD_RESUME"; + case APP_CMD_SAVE_STATE: return "APP_CMD_SAVE_STATE"; + case APP_CMD_PAUSE: return "APP_CMD_PAUSE"; + case APP_CMD_STOP: return "APP_CMD_STOP"; + case APP_CMD_DESTROY: return "APP_CMD_DESTROY"; + default: return "APP_CMD_???"; + } +} + extern "C" { android_app* g_android_app = nullptr; @@ -19,23 +50,32 @@ jobject g_callback = nullptr; jobject g_callbackAnimationFinished = nullptr; void handle_cmd(android_app *pApp, int32_t cmd) { + DebugLog::log(">> handle_cmd %s(%d) tid=%d", appCmdName(cmd), (int)cmd, dbg_tid()); switch (cmd) { case APP_CMD_INIT_WINDOW: aout << "APP_CMD_INIT_WINDOW" << std::endl; + DebugLog::log("handle_cmd APP_CMD_INIT_WINDOW: calling initVulkan()"); g_Application->initVulkan(); + DebugLog::log("handle_cmd APP_CMD_INIT_WINDOW: initVulkan() returned, isInited=%d", + (int)g_Application->isInited()); break; case APP_CMD_TERM_WINDOW: aout << "APP_CMD_TERM_WINDOW" << std::endl; + DebugLog::log("handle_cmd APP_CMD_TERM_WINDOW: (no handler yet, swapChain/surface still point to dead ANativeWindow)"); break; default: break; } + DebugLog::log("<< handle_cmd %s done", appCmdName(cmd)); } const int ArgLen = 128*1024; char g_InitArgString[ArgLen] = {0}; void android_main(struct android_app *pApp) { + DebugLog::init(pApp->activity->internalDataPath); + DebugLog::log("android_main start, pid=%d tid=%d, logPath=%s", + getpid(), dbg_tid(), DebugLog::getLogPath().c_str()); aout << "Welcome to android_main" << std::endl; g_android_app = pApp; g_assetManager = pApp->activity->assetManager; @@ -80,7 +120,38 @@ void android_main(struct android_app *pApp) { { auto frameTime = (start_time - _lastDrawFrameTime); _lastDrawFrameTime = chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count(); - g_Application->drawFrame(frameTime); + + static uint64_t s_frameIdx = 0; + static uint64_t s_excCount = 0; + static uint64_t s_lastLoggedExc = 0; + ++s_frameIdx; + if (s_frameIdx % 600 == 0) { + DebugLog::log("heartbeat: frame=%llu exceptions_so_far=%llu", + (unsigned long long)s_frameIdx, + (unsigned long long)s_excCount); + } + + try { + g_Application->drawFrame(frameTime); + } catch (const std::exception& e) { + ++s_excCount; + // Log first 10 exceptions verbosely, then at most one per 120 swallowed. + if (s_excCount <= 10 || (s_excCount - s_lastLoggedExc) >= 120) { + DebugLog::log("!!! drawFrame std::exception (frame=%llu count=%llu): %s", + (unsigned long long)s_frameIdx, + (unsigned long long)s_excCount, + e.what()); + s_lastLoggedExc = s_excCount; + } + } catch (...) { + ++s_excCount; + if (s_excCount <= 10 || (s_excCount - s_lastLoggedExc) >= 120) { + DebugLog::log("!!! drawFrame unknown exception (frame=%llu count=%llu)", + (unsigned long long)s_frameIdx, + (unsigned long long)s_excCount); + s_lastLoggedExc = s_excCount; + } + } } auto end_time = chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count(); auto frameTime = end_time - last_update_time; @@ -114,6 +185,12 @@ Java_com_hmwl_face_1sdk_FaceActivity_processImageNative(JNIEnv *env, jobject thi jint width, jint height, jint format, jint row_stride, jint pixel_stride, jint rotation) { + static std::atomic s_imgCount{0}; + uint64_t n = s_imgCount.fetch_add(1) + 1; + if (n == 1 || n % 300 == 0) { + DebugLog::log("processImageNative #%llu tid=%d w=%d h=%d", + (unsigned long long)n, dbg_tid(), width, height); + } // TODO: implement processImageNative() uint8_t* imageData = static_cast(env->GetDirectBufferAddress(buffer)); jlong capacity = env->GetDirectBufferCapacity(buffer); @@ -130,6 +207,12 @@ extern "C" JNIEXPORT void JNICALL Java_com_hmwl_face_1sdk_FaceActivity_passDataToNative(JNIEnv *env, jobject thiz, jobject buffer, jint point_count, jint width, jint height) { + static std::atomic s_ptCount{0}; + uint64_t n = s_ptCount.fetch_add(1) + 1; + if (n == 1 || n % 300 == 0) { + DebugLog::log("passDataToNative #%llu tid=%d point_count=%d w=%d h=%d", + (unsigned long long)n, dbg_tid(), point_count, width, height); + } // TODO: implement passDataToNative() float* pos = static_cast(env->GetDirectBufferAddress(buffer)); diff --git a/vulkan/Application.cpp b/vulkan/Application.cpp index 3eb1719..f9d6170 100644 --- a/vulkan/Application.cpp +++ b/vulkan/Application.cpp @@ -9,8 +9,47 @@ #include #include #include "../app/src/main/cpp/AndroidOut.h" + #include "../app/src/main/cpp/DebugLog.h" #endif +#ifdef _WIN32 +#define FACE_DBG_LOG(...) ((void)0) +#else +#define FACE_DBG_LOG(...) DebugLog::log(__VA_ARGS__) +#endif + +static const char* VkResultStr(VkResult r) { + switch (r) { + case VK_SUCCESS: return "VK_SUCCESS"; + case VK_NOT_READY: return "VK_NOT_READY"; + case VK_TIMEOUT: return "VK_TIMEOUT"; + case VK_EVENT_SET: return "VK_EVENT_SET"; + case VK_EVENT_RESET: return "VK_EVENT_RESET"; + case VK_INCOMPLETE: return "VK_INCOMPLETE"; + case VK_SUBOPTIMAL_KHR: return "VK_SUBOPTIMAL_KHR"; + case VK_ERROR_OUT_OF_HOST_MEMORY: return "VK_ERROR_OUT_OF_HOST_MEMORY"; + case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "VK_ERROR_OUT_OF_DEVICE_MEMORY"; + case VK_ERROR_INITIALIZATION_FAILED: return "VK_ERROR_INITIALIZATION_FAILED"; + case VK_ERROR_DEVICE_LOST: return "VK_ERROR_DEVICE_LOST"; + case VK_ERROR_MEMORY_MAP_FAILED: return "VK_ERROR_MEMORY_MAP_FAILED"; + case VK_ERROR_LAYER_NOT_PRESENT: return "VK_ERROR_LAYER_NOT_PRESENT"; + case VK_ERROR_EXTENSION_NOT_PRESENT: return "VK_ERROR_EXTENSION_NOT_PRESENT"; + case VK_ERROR_FEATURE_NOT_PRESENT: return "VK_ERROR_FEATURE_NOT_PRESENT"; + case VK_ERROR_INCOMPATIBLE_DRIVER: return "VK_ERROR_INCOMPATIBLE_DRIVER"; + case VK_ERROR_TOO_MANY_OBJECTS: return "VK_ERROR_TOO_MANY_OBJECTS"; + case VK_ERROR_FORMAT_NOT_SUPPORTED: return "VK_ERROR_FORMAT_NOT_SUPPORTED"; + case VK_ERROR_FRAGMENTED_POOL: return "VK_ERROR_FRAGMENTED_POOL"; + case VK_ERROR_OUT_OF_DATE_KHR: return "VK_ERROR_OUT_OF_DATE_KHR"; + case VK_ERROR_SURFACE_LOST_KHR: return "VK_ERROR_SURFACE_LOST_KHR"; + case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"; + case VK_ERROR_OUT_OF_POOL_MEMORY: return "VK_ERROR_OUT_OF_POOL_MEMORY"; + case VK_ERROR_INVALID_EXTERNAL_HANDLE: return "VK_ERROR_INVALID_EXTERNAL_HANDLE"; + case VK_ERROR_FRAGMENTATION: return "VK_ERROR_FRAGMENTATION"; + case VK_ERROR_UNKNOWN: return "VK_ERROR_UNKNOWN"; + default: return "VK_UNMAPPED_VALUE"; + } +} + void Application::initWindow() @@ -545,13 +584,24 @@ void Application::render(VkCommandBuffer commandBuffer, long long frameTime) void Application::drawFrame(long long frameTime) { + static uint64_t s_drawFrameCount = 0; + ++s_drawFrameCount; + // 1. 等待前一帧完成 - vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX); + VkResult waitRes = vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX); + if (waitRes != VK_SUCCESS) { + FACE_DBG_LOG("drawFrame[%llu] vkWaitForFences -> %d (%s) currentFrame=%u", + (unsigned long long)s_drawFrameCount, + (int)waitRes, VkResultStr(waitRes), currentFrame); + } // 2. 获取交换链图像 uint32_t imageIndex; VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex); if (result != VK_SUCCESS) { + FACE_DBG_LOG("drawFrame[%llu] vkAcquireNextImageKHR -> %d (%s) currentFrame=%u", + (unsigned long long)s_drawFrameCount, + (int)result, VkResultStr(result), currentFrame); throw std::runtime_error("failed to acquire swap chain image!"); } @@ -582,7 +632,12 @@ void Application::drawFrame(long long frameTime) submitInfo.signalSemaphoreCount = 1; submitInfo.pSignalSemaphores = signalSemaphores; - if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]) != VK_SUCCESS) { + VkResult submitRes = vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]); + if (submitRes != VK_SUCCESS) { + FACE_DBG_LOG("drawFrame[%llu] vkQueueSubmit -> %d (%s) currentFrame=%u imageIndex=%u", + (unsigned long long)s_drawFrameCount, + (int)submitRes, VkResultStr(submitRes), + currentFrame, imageIndex); throw std::runtime_error("failed to submit draw command buffer!"); } // 7. 呈现图像 @@ -597,6 +652,10 @@ void Application::drawFrame(long long frameTime) result = vkQueuePresentKHR(presentQueue, &presentInfo); if (result != VK_SUCCESS) { + FACE_DBG_LOG("drawFrame[%llu] vkQueuePresentKHR -> %d (%s) currentFrame=%u imageIndex=%u", + (unsigned long long)s_drawFrameCount, + (int)result, VkResultStr(result), + currentFrame, imageIndex); throw std::runtime_error("failed to present swap chain image!"); } diff --git a/vulkan/FaceApp.cpp b/vulkan/FaceApp.cpp index 620d04f..56e45eb 100644 --- a/vulkan/FaceApp.cpp +++ b/vulkan/FaceApp.cpp @@ -6,6 +6,13 @@ #include #include +#ifndef _WIN32 +#include "../app/src/main/cpp/DebugLog.h" +#define FACE_DBG_LOG(...) DebugLog::log(__VA_ARGS__) +#else +#define FACE_DBG_LOG(...) ((void)0) +#endif + FaceApp* FaceApp::faceIns = nullptr; @@ -772,6 +779,11 @@ void FaceApp::createVmaAllocator() void FaceApp::initVulkan() { + static int s_initVulkanCallCount = 0; + ++s_initVulkanCallCount; + FACE_DBG_LOG("FaceApp::initVulkan enter, call#%d _applicationInited=%d _faceAppInited=%d _secondfaceAppInited=%d", + s_initVulkanCallCount, (int)_applicationInited, (int)_faceAppInited, (int)_secondfaceAppInited); + Application::initVulkan(); if (!_faceAppInited) @@ -839,6 +851,9 @@ void FaceApp::initVulkan() _playMotion = true; _secondfaceAppInited = true; } + + FACE_DBG_LOG("FaceApp::initVulkan exit, call#%d _applicationInited=%d _faceAppInited=%d _secondfaceAppInited=%d", + s_initVulkanCallCount, (int)_applicationInited, (int)_faceAppInited, (int)_secondfaceAppInited); } void FaceApp::clearnSecondFaceApp()