AVI write thread

Author: manoreken2

MLDX12VideoCapture/MLAviWriter.cpp

@@ -1,5 +1,6 @@
 #include "MLAviWriter.h"
 #include <assert.h>
+#include "WinApp.h"
 
 namespace {
     struct AviMainHeader {
@@ -104,10 +105,26 @@ namespace {
 
 MLAviWriter::MLAviWriter(void)
     : mFp(nullptr), mLastRiffIdx(-1), mLastMoviIdx(-1)
-{}
+{
+    mState = AVIS_Init;
+    m_thread = nullptr;
+    m_shutdownEvent = CreateEventEx(nullptr, nullptr, 0, EVENT_MODIFY_STATE | SYNCHRONIZE);
+    m_readyEvent    = CreateEventEx(nullptr, nullptr, 0, EVENT_MODIFY_STATE | SYNCHRONIZE);
+}
 
 
-MLAviWriter::~MLAviWriter(void) {}
+MLAviWriter::~MLAviWriter(void)
+{
+    if (nullptr != m_readyEvent) {
+        CloseHandle(m_readyEvent);
+        m_readyEvent = nullptr;
+    }
+
+    if (nullptr != m_shutdownEvent) {
+        CloseHandle(m_shutdownEvent);
+        m_shutdownEvent = nullptr;
+    }
+}
 
 void MLAviWriter::WriteFccHeader(const char *fccS, int bytes) {
     uint32_t fcc = StringToFourCC(fccS);
@@ -164,27 +181,37 @@ bool MLAviWriter::Init(std::wstring path, int width, int height, int fps, ImageF
 
     mTotalFrames = 0;
 
+    StartThread();
     return true;
 }
 
 static const uint32_t  FCC_00db = 0x62643030;
 
 void MLAviWriter::AddImage(const uint32_t * img, int bytes) {
     assert(mFp != nullptr);
+    assert(m_readyEvent != nullptr);
 
-    if ((mTotalFrames % 30) == 29) {
-        RestartRiff();
+    if (mState != AVIS_Writing) {
+        return;
     }
 
-    WriteStreamDataHeader(FCC_00db, bytes);
-    fwrite(img, 1, bytes, mFp);
+    ImageItem ii;
+    ii.buf = new uint32_t[bytes / 4];
+    ii.bytes = bytes;
+    memcpy(ii.buf, img, bytes);
 
-    ++mTotalFrames;
+    m_mutex.lock();
+    mImageList.push_back(ii);
+    m_mutex.unlock();
+
+    SetEvent(m_readyEvent);
 }
 
 void MLAviWriter::Term(void) {
     assert(mFp != nullptr);
 
+    StopThread();
+
     FinishList(mLastMoviIdx);
     FinishRiff(mLastRiffIdx);
 
@@ -198,6 +225,14 @@ void MLAviWriter::Term(void) {
     mFp = nullptr;
 }
 
+int MLAviWriter::RecQueueSize(void) {
+    int count;
+    m_mutex.lock();
+    count = (int)mImageList.size();
+    m_mutex.unlock();
+    return count;
+
+}
 
 int MLAviWriter::WriteRiff(const char *fccS) {
     uint32_t fcc = StringToFourCC(fccS);
@@ -364,4 +399,101 @@ void MLAviWriter::RestartRiff(void) {
 
     mLastRiffIdx = WriteRiff("AVIX");
     mLastMoviIdx = WriteList("movi");
-}
+}
+
+// ============================================================
+// thread
+
+void MLAviWriter::StartThread(void)
+{
+    if (m_thread != nullptr) {
+        return;
+    }
+
+    mState = AVIS_Writing;
+    m_thread = CreateThread(nullptr, 0, AviWriterEntry, this, 0, nullptr);
+}
+
+void MLAviWriter::StopThread(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;
+}
+
+
+DWORD WINAPI
+MLAviWriter::AviWriterEntry(LPVOID param) {
+    MLAviWriter *self = (MLAviWriter *)param;
+
+    return self->ThreadMain();
+}
+
+DWORD
+MLAviWriter::ThreadMain(void) {
+    DWORD rv = 0;
+    CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+    HANDLE waitAry[2] = {m_shutdownEvent, m_readyEvent};
+    DWORD waitRv;
+
+    while (true) {
+        waitRv = WaitForMultipleObjects(2, waitAry, FALSE, INFINITE);
+        if (waitRv == WAIT_OBJECT_0) {
+            // flush remaining items.
+            WriteAll();
+            OutputDebugStringA("MLAviWriter::ThreadMain() exit\n");
+            break;
+        }
+
+        // ready event
+        WriteAll();
+    }
+
+    CoUninitialize();
+    return rv;
+}
+
+void
+MLAviWriter::WriteAll(void) {
+    ImageItem ii;
+
+    m_mutex.lock();
+    int count = (int)mImageList.size();
+    m_mutex.unlock();
+
+    while (0 < count) {
+        m_mutex.lock();
+        ii = mImageList.front();
+        mImageList.pop_front();
+        m_mutex.unlock();
+
+        WriteOne(ii);
+        delete[] ii.buf;
+        ii.buf = nullptr;
+
+        m_mutex.lock();
+        count = (int)mImageList.size();
+        m_mutex.unlock();
+    }
+}
+
+void
+MLAviWriter::WriteOne(ImageItem& ii)
+{
+    if ((mTotalFrames % 30) == 29) {
+        RestartRiff();
+    }
+
+    WriteStreamDataHeader(FCC_00db, ii.bytes);
+    fwrite(ii.buf, 1, ii.bytes, mFp);
+
+    ++mTotalFrames;
+}
+

MLDX12VideoCapture/MLAviWriter.h

@@ -4,6 +4,9 @@
 #include <stdint.h>
 #include <vector>
 #include <stdio.h>
+#include "Common.h"
+#include <list>
+#include <mutex>
 
 class MLAviWriter {
 public:
@@ -22,13 +25,22 @@ class MLAviWriter {
 
     bool IsOpen(void) const { return mFp != nullptr; }
 
+    int RecQueueSize(void);
+
 private:
 
     int mWidth;
     int mHeight;
     int mFps;
     int mImgFmt;
 
+    enum AVIState {
+        AVIS_Init,
+        AVIS_Writing,
+    };
+
+    AVIState mState;
+
     struct RiffChunk {
         uint64_t pos;
         uint64_t size;
@@ -44,6 +56,13 @@ class MLAviWriter {
     std::vector<RiffChunk> mRiffChunks;
     std::vector<ListChunk> mListChunks;
 
+    struct ImageItem {
+        uint32_t *buf;
+        int bytes;
+    };
+
+    std::list<ImageItem> mImageList;
+
     int mLastRiffIdx;
     int mLastMoviIdx;
 
@@ -71,5 +90,17 @@ class MLAviWriter {
     void RestartRiff(void);
 
     FILE *mFp;
+
+    std::mutex m_mutex;
+    HANDLE       m_thread;
+    HANDLE       m_shutdownEvent;
+    HANDLE       m_readyEvent;
+    static DWORD WINAPI AviWriterEntry(LPVOID param);
+    DWORD ThreadMain(void);
+    void WriteAll(void);
+    void WriteOne(ImageItem& ii);
+    void StartThread(void);
+    void StopThread(void);
+
 };
 

MLDX12VideoCapture/MLDX12App.cpp

@@ -39,6 +39,7 @@ MLDX12App::MLDX12App(UINT width, UINT height) :
     m_frameSkipCount(0)
 {
     strcpy_s(m_writePath, "c:/data/output.avi");
+    m_msg[0] = 0;
 }
 
 void MLDX12App::OnInit()
@@ -750,6 +751,7 @@ MLDX12App::ImGuiCommands(void)
                 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")) {
                         wchar_t path[512];
                         memset(path, 0, sizeof path);
@@ -760,6 +762,9 @@ MLDX12App::ImGuiCommands(void)
                             MLAviWriter::IF_YUV422v210);
                         if (bRv) {
                             m_state = S_Recording;
+                            m_msg[0] = 0;
+                        } else {
+                            sprintf_s(m_msg, "File open error : %s", m_writePath);
                         }
                     }
                 }
@@ -775,11 +780,12 @@ MLDX12App::ImGuiCommands(void)
             }
             m_mutex.unlock();
 
-            ImGui::Text("Queue size : %d", queueSize);
+            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;
 

MLDX12VideoCapture/MLDX12App.h

@@ -142,6 +142,8 @@ class MLDX12App : public MLDX12, IMLVideoCaptureCallback {
 
     char m_writePath[512];
 
+    char m_msg[512];
+
     void LoadPipeline(void);
     void LoadAssets(void);
     void PopulateCommandList(void);