display write flush popup

Author: manoreken2

MLDX12VideoCapture/MLAviWriter.cpp

@@ -133,7 +133,7 @@ void MLAviWriter::WriteFccHeader(const char *fccS, int bytes) {
 }
 
 
-bool MLAviWriter::Init(std::wstring path, int width, int height, int fps, ImageFormat imgFmt) {
+bool MLAviWriter::Start(std::wstring path, int width, int height, int fps, ImageFormat imgFmt) {
     assert(mFp == nullptr);
 
     mWidth = width;
@@ -207,22 +207,16 @@ void MLAviWriter::AddImage(const uint32_t * img, int bytes) {
     SetEvent(m_readyEvent);
 }
 
-void MLAviWriter::Term(void) {
-    assert(mFp != nullptr);
-
-    StopThread();
-
-    FinishList(mLastMoviIdx);
-    FinishRiff(mLastRiffIdx);
-
-    _fseeki64(mFp, mAviMainHeaderPos, SEEK_SET);
-    WriteAviMainHeader();
+void MLAviWriter::StopBlocking(void) {
+    if (mFp == nullptr) {
+        return;
+    }
 
-    _fseeki64(mFp, mAviStreamHeaderPos, SEEK_SET);
-    WriteAviStreamHeader();
+    StopThreadBlock();
+}
 
-    fclose(mFp);
-    mFp = nullptr;
+void MLAviWriter::StopAsync(void) {
+    StopThreadAsync();
 }
 
 int MLAviWriter::RecQueueSize(void) {
@@ -414,18 +408,42 @@ void MLAviWriter::StartThread(void)
     m_thread = CreateThread(nullptr, 0, AviWriterEntry, this, 0, nullptr);
 }
 
-void MLAviWriter::StopThread(void) {
+void MLAviWriter::StopThreadBlock(void) {
     if (m_thread == nullptr) {
         return;
     }
 
-    mState = AVIS_Init;
-
     assert(m_shutdownEvent != nullptr);
     SetEvent(m_shutdownEvent);
     WaitForSingleObject(m_thread, INFINITE);
     CloseHandle(m_thread);
     m_thread = nullptr;
+    mState = AVIS_Init;
+}
+
+void MLAviWriter::StopThreadAsync(void) {
+    if (m_thread == nullptr) {
+        return;
+    }
+
+    mState = AVIS_WaitThreadEnd;
+
+    assert(m_shutdownEvent != nullptr);
+    SetEvent(m_shutdownEvent);
+}
+
+bool MLAviWriter::PollThreadEnd(void) {
+    if (m_thread == nullptr) {
+        return true;
+    }
+
+    if (mState == AVIS_Init) {
+        CloseHandle(m_thread);
+        m_thread = nullptr;
+        return true;
+    }
+
+    return false;
 }
 
 
@@ -456,7 +474,21 @@ MLAviWriter::ThreadMain(void) {
         WriteAll();
     }
 
+    FinishList(mLastMoviIdx);
+    FinishRiff(mLastRiffIdx);
+
+    _fseeki64(mFp, mAviMainHeaderPos, SEEK_SET);
+    WriteAviMainHeader();
+
+    _fseeki64(mFp, mAviStreamHeaderPos, SEEK_SET);
+    WriteAviStreamHeader();
+
+    fclose(mFp);
+    mFp = nullptr;
+
     CoUninitialize();
+
+    mState = AVIS_Init;
     return rv;
 }
 

MLDX12VideoCapture/MLAviWriter.h

@@ -17,11 +17,19 @@ class MLAviWriter {
         IF_YUV422v210,
     };
 
-    bool Init(std::wstring path, int width, int height, int fps, ImageFormat imgFmt);
+    bool Start(std::wstring path, int width, int height, int fps, ImageFormat imgFmt);
 
     void AddImage(const uint32_t * img, int bytes);
 
-    void Term(void);
+    // send thread to flush remaining data and end.
+    // StopAsync() then call PallThreadEnd() every frame until PollThreadEnd() returns true
+    void StopAsync(void);
+
+    // returns true when writing thread ends
+    bool PollThreadEnd(void);
+
+    // blocking termination
+    void StopBlocking(void);
 
     bool IsOpen(void) const { return mFp != nullptr; }
 
@@ -37,6 +45,7 @@ class MLAviWriter {
     enum AVIState {
         AVIS_Init,
         AVIS_Writing,
+        AVIS_WaitThreadEnd,
     };
 
     AVIState mState;
@@ -100,7 +109,9 @@ class MLAviWriter {
     void WriteAll(void);
     void WriteOne(ImageItem& ii);
     void StartThread(void);
-    void StopThread(void);
+    void StopThreadBlock(void);
+
+    void StopThreadAsync(void);
 
 };
 

MLDX12VideoCapture/MLDX12App.cpp

@@ -709,8 +709,25 @@ MLDX12App::ImGuiCommands(void)
 {
     ImGui::Begin("Settings");
 
-    ImGui::Text("Average redraw frames per second : %.1f", ImGui::GetIO().Framerate);
+    if (ImGui::BeginPopupModal("ErrorPopup", NULL, ImGuiWindowFlags_AlwaysAutoResize)) {
+        ImGui::Text(m_msg);
+        if (ImGui::Button("OK", ImVec2(120, 0))) {
+            ImGui::CloseCurrentPopup();
+            m_msg[0] = 0;
+        }
+        ImGui::EndPopup();
+    }
 
+    if (ImGui::BeginPopupModal("WriteFlushPopup", NULL, ImGuiWindowFlags_AlwaysAutoResize)) {
+        ImGui::Text(m_msg);
+
+        if (m_state != S_WaitRecordEnd) {
+            ImGui::CloseCurrentPopup();
+        }
+        ImGui::EndPopup();
+    }
+
+    ImGui::Text("Average redraw frames per second : %.1f", ImGui::GetIO().Framerate);
     ImGui::Text("ALT+Enter to toggle fullscreen.");
 
     static int selectedDeviceIdx = 0;
@@ -733,78 +750,95 @@ MLDX12App::ImGuiCommands(void)
             m_videoCapture.SetCallback(this);
             bool brv = m_videoCapture.StartCapture(0);
             if (brv) {
-                m_state = S_Capturing;
+                m_state = S_Previewing;
+            }
+        }
+        break;
+    case S_WaitRecordEnd:
+        {
+            sprintf_s(m_msg, "Now Writing AVI...\nRemaining %d frames.", m_aviWriter.RecQueueSize());
+            m_mutex.lock();
+            bool bEnd = m_aviWriter.PollThreadEnd();
+            m_mutex.unlock();
+            if (bEnd) {
+                m_state = S_Previewing;
             }
         }
         break;
     case S_Recording:
-    case S_Capturing:
+    case S_Previewing:
         {
             int queueSize = 0;
+            m_mutex.lock();
+            if (!m_capturedImages.empty()) {
+                queueSize = (int)m_capturedImages.size();
+                auto & front = m_capturedImages.front();
+                ImGui::Text(front.imgFormat.c_str());
+            } else {
+                ImGui::Text("");
+            }
+            m_mutex.unlock();
 
-            if (m_state == S_Capturing) {
-                ImGui::Text("Now Capturing...");
-                BMDTimeScale ts = m_videoCapture.FrameRateTS();
-                BMDTimeValue tv = m_videoCapture.FrameRateTV();
-                ImGui::Text("Frame rate : %llu %llu", (uint64_t)ts, (uint64_t)tv);
+            BMDTimeScale ts = m_videoCapture.FrameRateTS();
+            BMDTimeValue tv = m_videoCapture.FrameRateTV();
+            ImGui::Text("Frame rate : %.1f", (double)ts / tv);
 
+            ImGui::Separator();
+
+            if (m_state == S_Previewing) {
+                ImGui::Text("Now Previewing...");
                 BMDPixelFormat pixFmt = m_videoCapture.PixelFormat();
                 if (bmdFormat10BitYUV == pixFmt) {
                     ImGui::InputText("Record filename", m_writePath, sizeof m_writePath - 1);
-                    ImGui::Text(m_msg);
-                    if (ImGui::Button("Record")) {
+                    if (ImGui::Button("Record", ImVec2(256, 64))) {
                         wchar_t path[512];
                         memset(path, 0, sizeof path);
                         MultiByteToWideChar(CP_UTF8, 0, m_writePath, sizeof m_writePath, path, 511);
 
-                        bool bRv = m_aviWriter.Init(path, m_videoCapture.Width(),
+                        bool bRv = m_aviWriter.Start(path, m_videoCapture.Width(),
                             m_videoCapture.Height(), (int)(ts / 1000),
                             MLAviWriter::IF_YUV422v210);
                         if (bRv) {
                             m_state = S_Recording;
                             m_msg[0] = 0;
                         } else {
-                            sprintf_s(m_msg, "File open error : %s", m_writePath);
+                            sprintf_s(m_msg, "Record Failed.\nFile open error : %s", m_writePath);
+                            ImGui::OpenPopup("ErrorPopup");
                         }
                     }
                 }
-            }
 
-            m_mutex.lock();
-            if (!m_capturedImages.empty()) {
-                queueSize = (int)m_capturedImages.size();
-                auto & front = m_capturedImages.front();
-                ImGui::Text(front.imgFormat.c_str());
-            } else {
-                ImGui::Text("");
-            }
-            m_mutex.unlock();
-
-            ImGui::Text("Draw Queue size : %d", queueSize);
-            ImGui::Text("Frame skip count : %lld", m_frameSkipCount);
-
-            if (m_state == S_Recording) {
-                ImGui::Text("Now Recording...");
-                ImGui::Text("Rec Queue size : %d", m_aviWriter.RecQueueSize());
-                if (ImGui::Button("Stop Recording")) {
-                    m_state = S_Capturing;
-
-                    m_mutex.lock();
-                    m_aviWriter.Term();
-                    m_mutex.unlock();
-                }
-            } else {
                 if (ImGui::Button("Stop Capture")) {
-            
+
                     m_videoCapture.StopCapture();
                     m_videoCapture.Term();
-            
+
                     m_videoCaptureDeviceList.Term();
                     m_videoCaptureDeviceList.Init();
 
                     m_state = S_Init;
                 }
+            } else if (m_state == S_Recording) {
+                ImGui::Text("Now Recording...");
+                ImGui::Text("Record filename : %s", m_writePath);
+                if (ImGui::Button("Stop Recording", ImVec2(256, 64))) {
+                    m_state = S_WaitRecordEnd;
+
+                    m_mutex.lock();
+                    m_aviWriter.StopAsync();
+                    m_mutex.unlock();
+
+                    ImGui::OpenPopup("WriteFlushPopup");
+                }
+
+                ImGui::Text("Rec Queue size : %d", m_aviWriter.RecQueueSize());
+            }
+
+            ImGui::Text("Draw Queue size : %d", queueSize);
+            if (ImGui::Button("Clear Draw Queue")) {
+                ClearDrawQueue();
             }
+            ImGui::Text("Frame Draw skip count : %lld", m_frameSkipCount);
 
             ImGui::BeginGroup();
             if (ImGui::RadioButton("Center Crosshair", m_crosshairType == CH_CenterCrosshair)) {
@@ -815,7 +849,7 @@ MLDX12App::ImGuiCommands(void)
                 m_crosshairType = CH_4Crosshairs;
             }
             ImGui::SameLine();
-            if (ImGui::RadioButton("None", m_crosshairType == CH_None)) {
+            if (ImGui::RadioButton("CHNone", m_crosshairType == CH_None)) {
                 m_crosshairType = CH_None;
             }
             ImGui::EndGroup();
@@ -831,7 +865,7 @@ MLDX12App::ImGuiCommands(void)
                 m_gridType = GR_6x6;
             }
             ImGui::SameLine();
-            if (ImGui::RadioButton("None", m_gridType == GR_None)) {
+            if (ImGui::RadioButton("GRNone", m_gridType == GR_None)) {
                 m_gridType = GR_None;
             }
             ImGui::EndGroup();
@@ -982,6 +1016,18 @@ MLDX12App::MLVideoCaptureCallback_VideoInputFrameArrived(IDeckLinkVideoInputFram
     m_mutex.unlock();
 }
 
+void MLDX12App::ClearDrawQueue(void)
+{
+    m_mutex.lock();
+    for (auto ite = m_capturedImages.begin(); ite != m_capturedImages.end(); ++ite) {
+        CapturedImage &ci = *ite;
+        delete [] ci.data;
+        ci.data = nullptr;
+    }
+    m_capturedImages.clear();
+    m_mutex.unlock();
+}
+
 void
 MLDX12App::UpdateVideoTexture(void) {
     m_mutex.lock();

MLDX12VideoCapture/MLDX12App.h

@@ -45,8 +45,9 @@ class MLDX12App : public MLDX12, IMLVideoCaptureCallback {
 
     enum State {
         S_Init,
-        S_Capturing,
+        S_Previewing,
         S_Recording,
+        S_WaitRecordEnd,
     };
 
     struct Vertex
@@ -152,6 +153,8 @@ class MLDX12App : public MLDX12, IMLVideoCaptureCallback {
     void LoadSizeDependentResources(void);
     void UpdateViewAndScissor(void);
 
+    void ClearDrawQueue(void);
+
     void CreateVideoTexture(int texIdx, int w, int h, DXGI_FORMAT fmt, int pixelBytes, uint8_t *data);
     void UpdateVideoTexture(void);