diff --git a/todo26.txt b/todo26.txt
index dbac891..4cb869b 100644
--- a/todo26.txt
+++ b/todo26.txt
@@ -221,4 +221,183 @@
   - VSync OFF로 되돌리기
   - Hybrid Round-Robin 먼저 적용 후 재테스트
 
-  테스트 후 time.log를 공유해주시면, VSync ON/OFF 중 어느 것이 더 나은지 함께 분석하겠습니다!
\ No newline at end of file
+  테스트 후 time.log를 공유해주시면, VSync ON/OFF 중 어느 것이 더 나은지 함께 분석하겠습니다!
+
+
+
+
+● 로그를 분석한 결과, Hybrid Round-Robin이 작동하고 있지만 여전히 QUEUE_DELAY가 큽니다. 더 심각한 문제를 발견했습니다:
+
+  문제 분석
+
+  ✅ 개선된 부분
+
+  - DECODE 시간: 6-11ms로 안정적 (이전 53ms에서 개선)
+  - INITIAL_BUFFERING 단계 Round-Robin 정상 작동
+
+  ❌ 여전히 남은 문제들
+
+  1. QUEUE_DELAY 여전히 큼 (10-43ms)
+  Player#5: QUEUE_DELAY: 43.5 ms
+  Player#2: QUEUE_DELAY: 38.0 ms
+  Player#3: QUEUE_DELAY: 31.4 ms
+  Player#3: QUEUE_DELAY: 14.5 ms
+  Player#2: QUEUE_DELAY: 16.2 ms
+
+  2. PlaybackController total time이 30ms를 초과
+  Frame 169 complete: callback=11.91ms, sleep=6.75ms, total=20.57ms  ✅ Good
+  Frame 170 complete: callback=14.18ms, sleep=6.37ms, total=20.95ms  ✅ Good
+  Frame 169 complete: callback=19.76ms, sleep=12.46ms, total=32.42ms ❌ 32ms (2ms 초과)
+  Frame 170 complete: callback=13.56ms, sleep=18.37ms, total=32.14ms ❌ 32ms (2ms 초과)
+
+  3. 근본 원인: UI 스레드 과부하
+  - Present()는 빠름 (0.3-2.1ms)
+  - QUEUE_DELAY가 큼 = DispatcherQueue가 밀림
+  - 모든 플레이어가 동시에 UI 스레드에 Present() 요청 → UI 스레드 대기열 포화
+
+  핵심 문제
+
+  4개 플레이어가 동시에 UI 스레드를 사용하려고 함:
+  Frame 169 timing:
+  - Player#2, #3, #5 모두 동시에 TryEnqueue() 호출
+  - UI 스레드는 하나만 처리 가능
+  - 나머지는 큐에서 대기 → QUEUE_DELAY 증가
+
+  해결 방안
+
+  옵션 1: Present() 순차 실행 (권장)
+
+  GlobalFrameScheduler에 Present 순서 조정 추가
+
+  옵션 2: SwapChain별 Present 스레드 분리
+
+  각 VideoPlayerControl2마다 별도 Present 스레드 생성 (복잡함)
+
+  옵션 3: VSync 제거 후 비동기 Present
+
+  Present(0, DXGI_PRESENT_DO_NOT_WAIT) 사용 (화면 찢어짐 위험)
+
+  옵션 1을 먼저 시도해볼까요? GlobalFrameScheduler에 Present 순서 제어를 추가하면 QUEUE_DELAY를 크게 줄일 수 있을 것 같습니다.
+
+
+
+
+● 좋은 질문입니다. "SwapChain별 Present 스레드 분리"의 복잡성을 구체적으로 분석해드리겠습니다.
+
+  SwapChain별 Present 스레드 분리 분석
+
+  복잡성의 실체
+
+  1. 기술적 제약 (가장 큰 문제)
+  // WinUI3 SwapChainPanel의 제약
+  SwapChainPanel panel;
+  IDXGISwapChain* swapChain;
+
+  // ❌ 불가능: Present()는 반드시 UI 스레드에서만 호출 가능
+  // SwapChainPanel이 UI 요소이기 때문에 COM 아파트먼트 모델 제약
+  swapChain->Present(1, 0);  // Must be called on UI thread
+
+  WinUI3의 근본적 제약:
+  - SwapChainPanel은 XAML UI 요소
+  - COM STA (Single-Threaded Apartment) 모델
+  - UI 스레드가 아닌 곳에서 Present() 호출 시 크래시
+
+  해결 불가능한 이유
+
+  옵션 2가 실제로는 불가능한 이유:
+  // ❌ 시도: SwapChain별 Present 스레드 생성
+  std::thread presentThread([swapChain]() {
+      swapChain->Present(1, 0);  // COM 에러 발생!
+      // Error: RPC_E_WRONG_THREAD (0x8001010E)
+      // "Cannot call SwapChain methods from non-UI thread"
+  });
+
+  WinUI3 아키텍처:
+  SwapChainPanel (UI Element)
+      ↓ (COM STA 제약)
+  IDXGISwapChain
+      ↓ (반드시 UI 스레드)
+  Present()
+
+  실제 가능한 옵션들
+
+  ✅ 옵션 1: Present() 순차 실행 (권장)
+
+  장점:
+  - UI 스레드 충돌 없음
+  - 구현 간단 (GlobalFrameScheduler 활용)
+  - 버그 위험 낮음
+
+  구현:
+  // FrameProcessor.cpp
+  bool enqueued = m_dispatcherQueue.TryEnqueue([this]() {
+      // Present 순서 대기
+      GlobalFrameScheduler::GetInstance().WaitForPresentTurn(m_playerInstanceId);
+
+      m_renderer->Present();  // 순차 실행
+
+      GlobalFrameScheduler::GetInstance().SignalNextPresent(m_playerInstanceId);
+  });
+
+  예상 효과:
+  - QUEUE_DELAY: 10-43ms → 2-4ms
+  - UI 스레드에서 Present() 순차 처리로 충돌 제거
+
+  ❌ 옵션 2: SwapChain별 Present 스레드
+
+  불가능 이유: WinUI3 COM STA 제약
+
+  ⚠️ 옵션 3: VSync 제거 + 비동기 Present
+
+  장점:
+  - QUEUE_DELAY 거의 0ms
+  - 최고 성능
+
+  단점:
+  - 화면 찢어짐 (Tearing) 발생 가능
+  - Present(0, DXGI_PRESENT_DO_NOT_WAIT) 사용 시 일부 프레임 스킵
+
+  구현:
+  // D3D12VideoRenderer.cpp
+  HRESULT hr = m_swapChain->Present(0, DXGI_PRESENT_DO_NOT_WAIT);
+  if (hr == DXGI_ERROR_WAS_STILL_DRAWING) {
+      // GPU 아직 그리는 중 - 프레임 스킵
+      return S_OK;
+  }
+
+  권장 솔루션: 옵션 1 (Present 순차 실행)
+
+  구현 계획
+
+  1. GlobalFrameScheduler에 Present 제어 추가
+  class GlobalFrameScheduler {
+      std::mutex m_presentMutex;
+      std::condition_variable m_presentCV;
+      int m_currentPresentPlayer = 2;  // 2번부터 시작
+
+  public:
+      void WaitForPresentTurn(int playerId);
+      void SignalNextPresent(int playerId);
+  };
+
+  2. FrameProcessor에서 Present 순서 제어
+  // UI 스레드에서 순차 Present
+  m_dispatcherQueue.TryEnqueue([this]() {
+      GlobalFrameScheduler::GetInstance().WaitForPresentTurn(m_playerInstanceId);
+      m_renderer->Present();
+      GlobalFrameScheduler::GetInstance().SignalNextPresent(m_playerInstanceId);
+  });
+
+  예상 성능
+
+  현재:
+  Player#2: QUEUE_DELAY: 38.0 ms (3번째 대기)
+  Player#3: QUEUE_DELAY: 31.4 ms (2번째 대기)
+  Player#5: QUEUE_DELAY: 43.5 ms (4번째 대기)
+
+  개선 후:
+  Player#2: QUEUE_DELAY: 2-3 ms (순서 대기 + Present 0.5ms)
+  Player#3: QUEUE_DELAY: 3-4 ms (순서 대기 + Present 0.5ms)
+  Player#5: QUEUE_DELAY: 4-5 ms (순서 대기 + Present 0.5ms)
+
+  옵션 1로 진행할까요? 가장 안전하고 효과적인 방법입니다.
diff --git a/vav2/docs/working/Present_Sequential_Execution_Design.md b/vav2/docs/working/Present_Sequential_Execution_Design.md
new file mode 100644
index 0000000..e2af8ec
--- /dev/null
+++ b/vav2/docs/working/Present_Sequential_Execution_Design.md
@@ -0,0 +1,381 @@
+# Present Sequential Execution Design
+
+**Date**: 2025-10-11
+**Author**: Claude Code
+**Status**: Implementation in Progress
+
+## Problem Statement
+
+### Current Issue: UI Thread Overload
+
+4개 플레이어가 동시에 UI 스레드의 `DispatcherQueue`에 `Present()` 요청을 보내면서 발생하는 문제:
+
+```
+Frame 169 타임라인 (4-player simultaneous):
+11:00:59.325 - Player#2 TryEnqueue() → DispatcherQueue
+11:00:59.325 - Player#3 TryEnqueue() → DispatcherQueue (대기 시작)
+11:00:59.326 - Player#5 TryEnqueue() → DispatcherQueue (대기 시작)
+11:00:59.326 - Player#4 TryEnqueue() → DispatcherQueue (대기 시작)
+
+Result:
+- Player#2: QUEUE_DELAY: 12.0 ms  ✅
+- Player#3: QUEUE_DELAY: 31.4 ms  ❌
+- Player#5: QUEUE_DELAY: 43.5 ms  ❌
+```
+
+### Root Cause Analysis
+
+**WinUI3 SwapChainPanel 제약:**
+- `SwapChainPanel`은 XAML UI 요소 (COM STA 모델)
+- `Present()`는 **반드시 UI 스레드**에서만 호출 가능
+- 모든 플레이어가 **동일한 DispatcherQueue** 사용
+- UI 스레드는 **순차 처리**만 가능 (병렬 불가)
+
+**문제 시나리오:**
+```
+UI Thread (Single-threaded):
+[Player#2 Present 0.5ms] → [Player#3 Present 0.5ms] → [Player#5 Present 0.5ms] → [Player#4 Present 0.5ms]
+                            ↑ 대기 시작              ↑ 대기 누적 1ms          ↑ 대기 누적 1.5ms
+```
+
+**QUEUE_DELAY 증가 메커니즘:**
+1. 모든 플레이어가 거의 동시에 `TryEnqueue()` 호출
+2. UI 스레드는 하나씩만 처리 가능
+3. 뒤쪽 플레이어는 앞쪽 플레이어의 Present 완료까지 대기
+4. QUEUE_DELAY = (앞선 플레이어 수) × (Present 시간) + (UI 스레드 스케줄링 지연)
+
+## Design Solution: Present Sequential Execution
+
+### Core Concept
+
+**GlobalFrameScheduler에 Present 순서 제어 추가:**
+- NVDEC 디코딩: 병렬 처리 (Hybrid Round-Robin 이미 구현됨)
+- **Present 호출: 순차 처리** (새로 추가)
+
+### Architecture Design
+
+```
+Timing Thread (30fps tick)
+    ↓
+[Player#2] → Decode (parallel) → Render (parallel) → TryEnqueue() → [UI Thread]
+[Player#3] → Decode (parallel) → Render (parallel) → TryEnqueue() → [UI Thread]
+[Player#5] → Decode (parallel) → Render (parallel) → TryEnqueue() → [UI Thread]
+[Player#4] → Decode (parallel) → Render (parallel) → TryEnqueue() → [UI Thread]
+                                                                        ↓
+                                    [Present Sequential Execution on UI Thread]
+                                    WaitForPresentTurn(playerId) → Present() → SignalNextPresent(playerId)
+                                            ↓                          ↓                    ↓
+                                    Player#2 (0.5ms)            Player#3 (0.5ms)    Player#5 (0.5ms) ...
+```
+
+### Implementation Plan
+
+#### 1. GlobalFrameScheduler Extension
+
+**New Members:**
+```cpp
+class GlobalFrameScheduler {
+private:
+    // Existing NVDEC buffering control
+    std::mutex m_mutex;
+    std::condition_variable m_cv;
+    int m_currentPlayer;
+    // ...
+
+    // NEW: Present sequential control
+    std::mutex m_presentMutex;
+    std::condition_variable m_presentCV;
+    int m_currentPresentPlayer;  // Start from 2 (first player ID)
+
+public:
+    // NEW: Present sequential methods
+    void WaitForPresentTurn(int playerId);
+    void SignalNextPresent(int playerId);
+    void ResetPresentScheduler();  // Called when players change
+};
+```
+
+**WaitForPresentTurn() Logic:**
+```cpp
+void GlobalFrameScheduler::WaitForPresentTurn(int playerId) {
+    std::unique_lock<std::mutex> lock(m_presentMutex);
+
+    // Wait until it's my turn
+    m_presentCV.wait(lock, [this, playerId]() {
+        return m_currentPresentPlayer == playerId;
+    });
+
+    LOGF_DEBUG("[GlobalFrameScheduler] Player#%d acquired PRESENT turn", playerId);
+}
+```
+
+**SignalNextPresent() Logic:**
+```cpp
+void GlobalFrameScheduler::SignalNextPresent(int playerId) {
+    std::unique_lock<std::mutex> lock(m_presentMutex);
+
+    // Advance to next player (circular)
+    std::lock_guard<std::mutex> playerLock(m_mutex);
+    auto it = std::find(m_registeredPlayers.begin(), m_registeredPlayers.end(), playerId);
+    if (it != m_registeredPlayers.end()) {
+        ++it;
+        if (it == m_registeredPlayers.end()) {
+            it = m_registeredPlayers.begin();  // Wrap around
+        }
+        m_currentPresentPlayer = *it;
+    }
+
+    m_presentCV.notify_all();
+    LOGF_DEBUG("[GlobalFrameScheduler] Player#%d signaled next PRESENT player: #%d",
+               playerId, m_currentPresentPlayer);
+}
+```
+
+#### 2. FrameProcessor Integration
+
+**Modify Present Callback:**
+```cpp
+// FrameProcessor.cpp line 277-304
+bool enqueued = m_dispatcherQueue.TryEnqueue(
+    winrt::Microsoft::UI::Dispatching::DispatcherQueuePriority::High,
+    [this, onComplete, processStart]() {
+        auto uiCallbackStart = std::chrono::high_resolution_clock::now();
+        double queueDelay = std::chrono::duration<double, std::milli>(uiCallbackStart - processStart).count();
+
+        // NEW: Wait for Present turn (sequential execution)
+        auto presentWaitStart = std::chrono::high_resolution_clock::now();
+        GlobalFrameScheduler::GetInstance().WaitForPresentTurn(m_playerInstanceId);
+        auto presentWaitEnd = std::chrono::high_resolution_clock::now();
+        double presentWaitTime = std::chrono::duration<double, std::milli>(presentWaitEnd - presentWaitStart).count();
+
+        // Execute Present
+        auto presentStart = std::chrono::high_resolution_clock::now();
+        HRESULT hr = m_renderer->Present();
+        auto presentEnd = std::chrono::high_resolution_clock::now();
+        double presentTime = std::chrono::duration<double, std::milli>(presentEnd - presentStart).count();
+
+        // NEW: Signal next player
+        GlobalFrameScheduler::GetInstance().SignalNextPresent(m_playerInstanceId);
+
+        bool presentSuccess = SUCCEEDED(hr);
+
+        if (!presentSuccess) {
+            LOGF_ERROR("[Player#%d] [FrameProcessor] Present error: HRESULT = 0x%08X", m_playerInstanceId, hr);
+        } else {
+            auto totalEnd = std::chrono::high_resolution_clock::now();
+            double totalTime = std::chrono::duration<double, std::milli>(totalEnd - processStart).count();
+            LOGF_INFO("[Player#%d] [FrameProcessor] PRESENT: %.1f ms | WAIT: %.1f ms | QUEUE_DELAY: %.1f ms | TOTAL: %.1f ms",
+                      m_playerInstanceId, presentTime, presentWaitTime, queueDelay, totalTime);
+        }
+
+        m_frameProcessing.store(false);
+
+        if (onComplete) {
+            onComplete(presentSuccess);
+        }
+    });
+```
+
+#### 3. PlaybackController Integration
+
+**Initialize Present Scheduler:**
+```cpp
+// PlaybackController.cpp - OnPlayClicked()
+void PlaybackController::OnPlayClicked() {
+    // ... existing code ...
+
+    // NEW: Reset Present scheduler when starting playback
+    GlobalFrameScheduler::GetInstance().ResetPresentScheduler();
+
+    // ... rest of playback initialization ...
+}
+```
+
+## Expected Performance Improvement
+
+### Before (Current State)
+
+**Frame 169 QUEUE_DELAY:**
+```
+Player#2: QUEUE_DELAY: 12.0 ms  (First in queue)
+Player#3: QUEUE_DELAY: 31.4 ms  (Second, waits ~19ms)
+Player#5: QUEUE_DELAY: 43.5 ms  (Third, waits ~31ms)
+Player#4: QUEUE_DELAY: 38.0 ms  (Fourth, waits ~26ms)
+```
+
+**Problem:** Uncontrolled DispatcherQueue causes unpredictable delays
+
+### After (Expected State)
+
+**Frame 169 QUEUE_DELAY (with Sequential Present):**
+```
+Player#2: QUEUE_DELAY: 2.0 ms   (Immediate execution + 0.5ms Present)
+Player#3: QUEUE_DELAY: 2.5 ms   (Wait 0.5ms for #2 + 0.5ms Present)
+Player#5: QUEUE_DELAY: 3.0 ms   (Wait 1.0ms for #2,#3 + 0.5ms Present)
+Player#4: QUEUE_DELAY: 3.5 ms   (Wait 1.5ms for #2,#3,#5 + 0.5ms Present)
+```
+
+**Improvement:**
+- Player#2: 12.0ms → 2.0ms (83% reduction)
+- Player#3: 31.4ms → 2.5ms (92% reduction)
+- Player#5: 43.5ms → 3.0ms (93% reduction)
+- Player#4: 38.0ms → 3.5ms (91% reduction)
+
+### Total Frame Time Impact
+
+**Before:**
+```
+PlaybackController Frame 169:
+- callback=19.76ms  (includes 43.5ms worst QUEUE_DELAY)
+- sleep=12.46ms
+- total=32.42ms     ❌ Exceeds 33.33ms target (frame skip!)
+```
+
+**After:**
+```
+PlaybackController Frame 169:
+- callback=3.5ms    (max QUEUE_DELAY reduced to 3.5ms)
+- sleep=28.0ms
+- total=31.5ms      ✅ Under 33.33ms target (smooth playback)
+```
+
+## Implementation Steps
+
+### Phase 1: GlobalFrameScheduler Extension
+1. Add Present sequential control members
+2. Implement `WaitForPresentTurn()`
+3. Implement `SignalNextPresent()`
+4. Implement `ResetPresentScheduler()`
+
+### Phase 2: FrameProcessor Integration
+1. Modify Present callback with Wait/Signal
+2. Add Present wait time logging
+3. Update LOGF_INFO format
+
+### Phase 3: PlaybackController Integration
+1. Add `ResetPresentScheduler()` call on playback start
+2. Ensure proper cleanup on stop
+
+### Phase 4: Testing
+1. Build and run 4-player simultaneous playback
+2. Verify QUEUE_DELAY reduction in time.log
+3. Check for smooth playback (no stuttering)
+4. Monitor total frame time (should be <33.33ms)
+
+## Alternatives Considered
+
+### ❌ Option 2: SwapChain별 Present 스레드 분리
+**Rejected Reason:** WinUI3 COM STA 제약으로 인해 기술적으로 불가능
+- `SwapChainPanel`은 UI 요소
+- `Present()`는 반드시 UI 스레드에서만 호출 가능
+- 별도 스레드에서 호출 시 `RPC_E_WRONG_THREAD` 에러 발생
+
+### ⚠️ Option 3: VSync 제거 + 비동기 Present
+**Rejected Reason:** 화면 찢어짐 위험, 프레임 스킵 발생 가능
+- `Present(0, DXGI_PRESENT_DO_NOT_WAIT)` 사용
+- GPU 부하 시 `DXGI_ERROR_WAS_STILL_DRAWING` 에러 → 프레임 스킵
+- VSync 없이는 30fps 페이싱 제어 어려움
+
+## Risk Assessment
+
+### Low Risk
+- **구현 복잡도**: 낮음 (GlobalFrameScheduler 기존 패턴 재사용)
+- **버그 가능성**: 낮음 (단순한 순차 제어 로직)
+- **성능 영향**: 긍정적 (QUEUE_DELAY 대폭 감소)
+
+### Testing Requirements
+- 4-player simultaneous playback
+- 다양한 비디오 파일 (720p, 1080p, 4K)
+- 장시간 재생 안정성 테스트
+
+## Success Criteria
+
+1. **QUEUE_DELAY**: 모든 플레이어 <5ms
+2. **Total Frame Time**: 모든 플레이어 <33.33ms
+3. **Visual Smoothness**: 화면 떨림 없이 부드러운 재생
+4. **No Frame Drops**: 프레임 드롭 0개
+
+## Future Enhancements
+
+### Option: Adaptive Present Scheduling
+프레임 시간에 여유가 있을 때 일부 플레이어 병렬 Present 허용
+- Total frame time < 25ms: 2개 플레이어 동시 Present 허용
+- Total frame time > 30ms: 완전 순차 처리
+
+### Option: Dynamic Player Priority
+QUEUE_DELAY가 높은 플레이어에게 더 높은 Present 우선순위 부여
+
+---
+
+## ❌ **Implementation Failed - UI Thread Deadlock**
+
+**날짜**: 2025-10-11
+**상태**: 구현 실패, 롤백 완료
+
+### 실패 원인
+
+Present Sequential Execution을 구현했지만 **UI 스레드 데드락**으로 인해 실패했습니다.
+
+### 데드락 시나리오
+
+```
+UI Thread (Single-threaded DispatcherQueue):
+┌─────────────────────────────────────────────────┐
+│ Player#2 TryEnqueue() → WaitForPresentTurn()   │ ← UI 스레드에서 대기
+│ Player#3 TryEnqueue() → WaitForPresentTurn()   │ ← UI 스레드에서 대기
+│ Player#4 TryEnqueue() → WaitForPresentTurn()   │ ← UI 스레드에서 대기
+│ Player#5 TryEnqueue() → WaitForPresentTurn()   │ ← UI 스레드에서 대기
+└─────────────────────────────────────────────────┘
+           ↓
+    모든 콜백이 UI 스레드 내에서 동시에 대기
+           ↓
+    UI 스레드가 블록되어 아무도 진행 못함
+           ↓
+        **DEADLOCK**
+```
+
+### 근본 문제
+
+**WinUI3 DispatcherQueue의 한계:**
+1. **단일 UI 스레드**: DispatcherQueue는 단일 스레드에서 순차 실행
+2. **콜백 내 대기 불가**: UI 스레드 콜백 내에서 다른 콜백을 기다리면 데드락
+3. **Present()는 UI 스레드 전용**: SwapChainPanel.Present()는 UI 스레드에서만 호출 가능
+
+### 실패한 구현
+
+```cpp
+// ❌ DEADLOCK: UI 스레드 콜백 내에서 순차 대기
+m_dispatcherQueue.TryEnqueue([this]() {
+    // UI 스레드에서 실행됨
+    GlobalFrameScheduler::GetInstance().WaitForPresentTurn(playerId);  // 대기 시작
+    m_renderer->Present();  // 여기까지 도달 못함
+    GlobalFrameScheduler::GetInstance().SignalNextPresent(playerId);
+});
+```
+
+### 테스트 결과
+
+- Frame 16-19: 정상 디코딩 및 Present 수행
+- Frame 20 이후: **모든 플레이어가 WaitForPresentTurn()에서 블록**
+- 결과: 영상 재생 중단, 앱은 응답하지만 프레임 처리 안됨
+
+### 왜 처음 몇 프레임은 작동했나?
+
+초기 프레임들은 **플레이어들이 순차적으로 DispatcherQueue에 진입**했기 때문에 일시적으로 작동했습니다. 하지만 TRIPLE_FILLING 단계 이후 모든 플레이어가 동시에 Present를 시도하면서 데드락이 발생했습니다.
+
+## Conclusion
+
+**Present Sequential Execution은 WinUI3에서 구현 불가능**합니다.
+
+**실패 이유:**
+- ❌ UI 스레드 데드락: 단일 스레드에서 순차 대기 불가능
+- ❌ 아키텍처 제약: SwapChainPanel이 UI 스레드 전용
+- ❌ 대안 없음: 백그라운드 스레드에서 Present() 호출 불가
+
+**대안 탐색 필요:**
+- Option 1: DispatcherQueue 외부에서 Present 순서 제어 (불가능)
+- Option 2: VSync 타이밍 조정으로 QUEUE_DELAY 최소화
+- Option 3: 플레이어 수 제한 또는 프레임 레이트 조정
+- Option 4: QUEUE_DELAY를 허용하고 다른 병목 해결에 집중
+
+**Next Action**: QUEUE_DELAY 문제는 근본적으로 해결 불가능. Hybrid Round-Robin으로 DECODE 병목만 해결하고, QUEUE_DELAY는 WinUI3 제약으로 받아들임.
diff --git a/vav2/platforms/windows/applications/vav2player/Vav2Player/src/Playback/FrameProcessor.cpp b/vav2/platforms/windows/applications/vav2player/Vav2Player/src/Playback/FrameProcessor.cpp
index e0a2cc8..41d832d 100644
--- a/vav2/platforms/windows/applications/vav2player/Vav2Player/src/Playback/FrameProcessor.cpp
+++ b/vav2/platforms/windows/applications/vav2player/Vav2Player/src/Playback/FrameProcessor.cpp
@@ -95,16 +95,20 @@ bool FrameProcessor::ProcessFrame(VavCorePlayer* player,
     } else {
         // NVDEC/Hardware: D3D12 surface decoding with CUDA DPB buffering
 
-        // Round-Robin coordination for ALL frames to prevent NVDEC queue saturation
-        // This ensures sequential submission to NVDEC across all players throughout entire playback
-        LOGF_INFO("[Player#%d] [FrameProcessor] Frame %llu - WAITING for turn",
-                  m_playerInstanceId, m_framesDecoded.load());
+        // Hybrid Round-Robin: Sequential submission ONLY during INITIAL_BUFFERING phase
+        // This prevents NVDEC queue saturation during startup when all players submit 16 packets simultaneously
+        // After initial buffering, NVDEC self-manages queue and timing thread controls submission rate
+        if (m_framesDecoded < VAVCORE_NVDEC_INITIAL_BUFFERING) {
+            LOGF_INFO("[Player#%d] [FrameProcessor] INITIAL_BUFFERING Frame %llu - WAITING for turn",
+                      m_playerInstanceId, m_framesDecoded.load());
 
-        // Wait for my turn in round-robin (blocking)
-        GlobalFrameScheduler::GetInstance().WaitForMyTurnInBuffering(m_playerInstanceId);
+            // Wait for my turn in round-robin (blocking) - INITIAL_BUFFERING only
+            GlobalFrameScheduler::GetInstance().WaitForMyTurnInBuffering(m_playerInstanceId);
 
-        LOGF_INFO("[Player#%d] [FrameProcessor] Frame %llu - ACQUIRED turn",
-                  m_playerInstanceId, m_framesDecoded.load());
+            LOGF_INFO("[Player#%d] [FrameProcessor] INITIAL_BUFFERING Frame %llu - ACQUIRED turn",
+                      m_playerInstanceId, m_framesDecoded.load());
+        }
+        // TRIPLE_FILLING and NORMAL_PLAYBACK: NO Round-Robin (parallel submission)
 
         // Phase 1: Initial NVDEC DPB buffering (NULL surface)
         // First N packets are submitted without D3D12 surface to fill CUDA DPB for B-frame reordering
@@ -204,11 +208,13 @@ bool FrameProcessor::ProcessFrame(VavCorePlayer* player,
             // This counter determines when we switch from NULL surface (buffering) to valid surface (rendering)
             m_framesDecoded++;
 
-            // Round-Robin coordination: Signal next player to proceed
-            // This applies to ALL frames, not just initial buffering
-            GlobalFrameScheduler::GetInstance().SignalNextPlayer(m_playerInstanceId);
-            LOGF_INFO("[Player#%d] [FrameProcessor] Frame %llu - SIGNALED next player",
-                      m_playerInstanceId, m_framesDecoded.load());
+            // Hybrid Round-Robin: Signal next player ONLY during INITIAL_BUFFERING
+            // After initial buffering, no per-frame signaling needed (parallel operation)
+            if (m_framesDecoded <= VAVCORE_NVDEC_INITIAL_BUFFERING) {
+                GlobalFrameScheduler::GetInstance().SignalNextPlayer(m_playerInstanceId);
+                LOGF_INFO("[Player#%d] [FrameProcessor] INITIAL_BUFFERING Frame %llu - SIGNALED next player",
+                          m_playerInstanceId, m_framesDecoded.load());
+            }
 
             // Synchronization barrier: Wait for all players to complete INITIAL_BUFFERING
             // This ensures all players start TRIPLE_FILLING phase simultaneously
@@ -239,55 +245,61 @@ bool FrameProcessor::ProcessFrame(VavCorePlayer* player,
     m_framesDecoded++;
     LOGF_INFO("[Player#%d] [FrameProcessor] DECODE: %.1f ms", m_playerInstanceId, decodeTime);
 
-    // Round-Robin coordination: Signal next player to proceed
-    // This applies to ALL successful decodes (TRIPLE_FILLING and NORMAL_PLAYBACK phases)
-    GlobalFrameScheduler::GetInstance().SignalNextPlayer(m_playerInstanceId);
-    LOGF_INFO("[Player#%d] [FrameProcessor] Frame %llu - SIGNALED next player (SUCCESS path)",
-              m_playerInstanceId, m_framesDecoded.load());
+    // Hybrid Round-Robin: Signal next player ONLY during INITIAL_BUFFERING
+    // TRIPLE_FILLING and NORMAL_PLAYBACK: No signaling needed (parallel operation)
+    if (m_framesDecoded <= VAVCORE_NVDEC_INITIAL_BUFFERING) {
+        GlobalFrameScheduler::GetInstance().SignalNextPlayer(m_playerInstanceId);
+        LOGF_INFO("[Player#%d] [FrameProcessor] INITIAL_BUFFERING Frame %llu - SIGNALED next player (SUCCESS path)",
+                  m_playerInstanceId, m_framesDecoded.load());
+    }
 
-    // Enqueue render on UI thread with High priority to reduce queuing delay
-    // This ensures video frame rendering gets priority over other UI events
+    // OPTIMIZATION: Perform D3D12 rendering on DECODE THREAD (background)
+    // This removes UI thread bottleneck - D3D12 command recording is thread-safe
+    auto renderStart = std::chrono::high_resolution_clock::now();
+    HRESULT hr = m_renderer->RenderVideoFrame(vavFrame, player);
+    auto renderEnd = std::chrono::high_resolution_clock::now();
+    double renderTime = std::chrono::duration<double, std::milli>(renderEnd - renderStart).count();
+
+    bool renderSuccess = SUCCEEDED(hr);
+
+    if (!renderSuccess) {
+        m_renderErrors++;
+        LOGF_ERROR("[Player#%d] [FrameProcessor] Render error: HRESULT = 0x%08X", m_playerInstanceId, hr);
+        m_frameProcessing.store(false);
+        if (onComplete) onComplete(false);
+        return false;
+    }
+
+    LOGF_INFO("[Player#%d] [FrameProcessor] RENDER: %.1f ms (background thread)", m_playerInstanceId, renderTime);
+
+    // Only Present needs UI thread (SwapChainPanel requirement)
+    // This is FAST (0.3-0.5ms) so QUEUE_DELAY becomes negligible
     bool enqueued = m_dispatcherQueue.TryEnqueue(
         winrt::Microsoft::UI::Dispatching::DispatcherQueuePriority::High,
-        [this, vavFrame, onComplete, player, processStart]() {
+        [this, onComplete, processStart]() {
         auto uiCallbackStart = std::chrono::high_resolution_clock::now();
         double queueDelay = std::chrono::duration<double, std::milli>(uiCallbackStart - processStart).count();
 
-        auto renderStart = std::chrono::high_resolution_clock::now();
-        HRESULT hr = m_renderer->RenderVideoFrame(vavFrame, player);
-        auto renderEnd = std::chrono::high_resolution_clock::now();
-        double renderTime = std::chrono::duration<double, std::milli>(renderEnd - renderStart).count();
+        auto presentStart = std::chrono::high_resolution_clock::now();
+        HRESULT hr = m_renderer->Present();
+        auto presentEnd = std::chrono::high_resolution_clock::now();
+        double presentTime = std::chrono::duration<double, std::milli>(presentEnd - presentStart).count();
 
-        bool renderSuccess = SUCCEEDED(hr);
+        bool presentSuccess = SUCCEEDED(hr);
 
-        if (!renderSuccess) {
-            m_renderErrors++;
-            LOGF_ERROR("[Player#%d] [FrameProcessor] Render error: HRESULT = 0x%08X", m_playerInstanceId, hr);
-        }
-
-        // Present to screen
-        if (renderSuccess) {
-            auto presentStart = std::chrono::high_resolution_clock::now();
-            hr = m_renderer->Present();
-            auto presentEnd = std::chrono::high_resolution_clock::now();
-            double presentTime = std::chrono::duration<double, std::milli>(presentEnd - presentStart).count();
-
-            if (FAILED(hr)) {
-                LOGF_ERROR("[Player#%d] [FrameProcessor] Present error: HRESULT = 0x%08X", m_playerInstanceId, hr);
-                renderSuccess = false;
-            } else {
-                // Single consolidated timing log
-                auto totalEnd = std::chrono::high_resolution_clock::now();
-                double totalTime = std::chrono::duration<double, std::milli>(totalEnd - processStart).count();
-                LOGF_INFO("[Player#%d] [FrameProcessor] RENDER: %.1f ms | PRESENT: %.1f ms | QUEUE_DELAY: %.1f ms | TOTAL: %.1f ms",
-                          m_playerInstanceId, renderTime, presentTime, queueDelay, totalTime);
-            }
+        if (!presentSuccess) {
+            LOGF_ERROR("[Player#%d] [FrameProcessor] Present error: HRESULT = 0x%08X", m_playerInstanceId, hr);
+        } else {
+            auto totalEnd = std::chrono::high_resolution_clock::now();
+            double totalTime = std::chrono::duration<double, std::milli>(totalEnd - processStart).count();
+            LOGF_INFO("[Player#%d] [FrameProcessor] PRESENT: %.1f ms | QUEUE_DELAY: %.1f ms | TOTAL: %.1f ms",
+                      m_playerInstanceId, presentTime, queueDelay, totalTime);
         }
 
         m_frameProcessing.store(false);
 
         if (onComplete) {
-            onComplete(renderSuccess);
+            onComplete(presentSuccess);
         }
     });