Better error callbacks

wysaid · wysaid · commit fdab776b682a · 2025-08-18T15:26:22.000+08:00
diff --git a/include/ccap_c.h b/include/ccap_c.h
@@ -73,6 +73,7 @@ typedef enum {
     CCAP_ERROR_DEVICE_OPEN_FAILED = 0x1003,    /**< Camera device open failed */
     CCAP_ERROR_DEVICE_START_FAILED = 0x1004,   /**< Camera start failed */
     CCAP_ERROR_DEVICE_STOP_FAILED = 0x1005,    /**< Camera stop failed */
+    CCAP_ERROR_INITIALIZATION_FAILED = 0x1006, /**< Initialization failed */
     CCAP_ERROR_UNSUPPORTED_RESOLUTION = 0x2001, /**< Requested resolution is not supported */
     CCAP_ERROR_UNSUPPORTED_PIXEL_FORMAT = 0x2002, /**< Requested pixel format is not supported */
     CCAP_ERROR_FRAME_RATE_SET_FAILED = 0x2003,  /**< Frame rate setting failed */
diff --git a/include/ccap_def.h b/include/ccap_def.h
@@ -242,6 +242,9 @@ enum class ErrorCode {
     /// Camera stop failed
     DeviceStopFailed = 0x1005,
     
+    /// Initialization failed
+    InitializationFailed = 0x1006,
+    
     /// Requested resolution is not supported
     UnsupportedResolution = 0x2001,
     
diff --git a/src/ccap_c.cpp b/src/ccap_c.cpp
@@ -481,6 +481,8 @@ static_assert(static_cast<uint32_t>(CCAP_ERROR_DEVICE_START_FAILED) == static_ca
               "C and C++ ErrorCode::DeviceStartFailed values must match");
 static_assert(static_cast<uint32_t>(CCAP_ERROR_DEVICE_STOP_FAILED) == static_cast<uint32_t>(ccap::ErrorCode::DeviceStopFailed),
               "C and C++ ErrorCode::DeviceStopFailed values must match");
+static_assert(static_cast<uint32_t>(CCAP_ERROR_INITIALIZATION_FAILED) == static_cast<uint32_t>(ccap::ErrorCode::InitializationFailed),
+              "C and C++ ErrorCode::InitializationFailed values must match");
 static_assert(static_cast<uint32_t>(CCAP_ERROR_UNSUPPORTED_RESOLUTION) == static_cast<uint32_t>(ccap::ErrorCode::UnsupportedResolution),
               "C and C++ ErrorCode::UnsupportedResolution values must match");
 static_assert(static_cast<uint32_t>(CCAP_ERROR_UNSUPPORTED_PIXEL_FORMAT) == static_cast<uint32_t>(ccap::ErrorCode::UnsupportedPixelFormat),
diff --git a/src/ccap_core.cpp b/src/ccap_core.cpp
@@ -37,9 +37,9 @@ ProviderImp* createProviderV4L2();
 
 // Global error callback storage
 namespace {
-    std::mutex g_errorCallbackMutex;
-    ErrorCallback g_globalErrorCallback;
-}
+std::mutex g_errorCallbackMutex;
+ErrorCallback g_globalErrorCallback;
+} // namespace
 
 void setErrorCallback(ErrorCallback callback) {
     std::lock_guard<std::mutex> lock(g_errorCallbackMutex);
@@ -67,6 +67,11 @@ void DefaultAllocator::resize(size_t size) {
     // 32字节对齐，满足主流SIMD指令集需求(AVX)
     size_t alignedSize = (size + 31) & ~size_t(31);
     m_data = static_cast<uint8_t*>(ALIGNED_ALLOC(32, alignedSize));
+    if (!m_data) {
+        ccap::reportError(ErrorCode::MemoryAllocationFailed, "Failed to allocate " + std::to_string(alignedSize) + " bytes of aligned memory");
+        m_size = 0;
+        return;
+    }
     m_size = alignedSize;
     CCAP_LOG_V("ccap: Allocated %zu bytes of memory at %p\n", m_size, m_data);
 }
@@ -114,12 +119,17 @@ ProviderImp* createProvider(std::string_view extraInfo) {
     if (warningLogEnabled()) {
         CCAP_LOG_W("ccap: Unsupported platform!\n");
     }
+    ccap::reportError(ErrorCode::InitializationFailed, "Unsupported platform");
 #endif
     return nullptr;
 }
 
 Provider::Provider() :
-    m_imp(createProvider("")) {}
+    m_imp(createProvider("")) {
+    if (!m_imp) {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::FAILED_TO_CREATE_PROVIDER);
+    }
+}
 
 Provider::~Provider() {
     CCAP_LOG_V("ccap: Provider::~Provider() called, this=%p, imp=%p\n", this, m_imp);
@@ -130,24 +140,35 @@ Provider::Provider(std::string_view deviceName, std::string_view extraInfo) :
     m_imp(createProvider(extraInfo)) {
     if (m_imp) {
         open(deviceName);
+    } else {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::FAILED_TO_CREATE_PROVIDER);
     }
 }
 
 Provider::Provider(int deviceIndex, std::string_view extraInfo) :
     m_imp(createProvider(extraInfo)) {
     if (m_imp) {
         open(deviceIndex);
+    } else {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::FAILED_TO_CREATE_PROVIDER);
     }
 }
 
 std::vector<std::string> Provider::findDeviceNames() { return m_imp ? m_imp->findDeviceNames() : std::vector<std::string>(); }
 
 bool Provider::open(std::string_view deviceName, bool autoStart) {
-    return m_imp && m_imp->open(deviceName) && (!autoStart || m_imp->start());
+    if (!m_imp) {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::PROVIDER_IMPLEMENTATION_NULL);
+        return false;
+    }
+    return m_imp->open(deviceName) && (!autoStart || m_imp->start());
 }
 
 bool Provider::open(int deviceIndex, bool autoStart) {
-    if (!m_imp) return false;
+    if (!m_imp) {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::PROVIDER_IMPLEMENTATION_NULL);
+        return false;
+    }
 
     std::string deviceName;
     if (deviceIndex >= 0) {
@@ -167,32 +188,74 @@ bool Provider::isOpened() const { return m_imp && m_imp->isOpened(); }
 
 std::optional<DeviceInfo> Provider::getDeviceInfo() const { return m_imp ? m_imp->getDeviceInfo() : std::nullopt; }
 
-void Provider::close() { m_imp->close(); }
+void Provider::close() {
+    if (m_imp) {
+        m_imp->close();
+    }
+}
 
-bool Provider::start() { return m_imp && m_imp->start(); }
+bool Provider::start() {
+    if (!m_imp) {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::PROVIDER_IMPLEMENTATION_NULL);
+        return false;
+    }
+    return m_imp->start();
+}
 
 void Provider::stop() {
     if (m_imp) m_imp->stop();
 }
 
 bool Provider::isStarted() const { return m_imp && m_imp->isStarted(); }
 
-bool Provider::set(PropertyName prop, double value) { return m_imp->set(prop, value); }
+bool Provider::set(PropertyName prop, double value) {
+    if (!m_imp) {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::PROVIDER_IMPLEMENTATION_NULL);
+        return false;
+    }
+    return m_imp->set(prop, value);
+}
 
 double Provider::get(PropertyName prop) { return m_imp ? m_imp->get(prop) : NAN; }
 
-std::shared_ptr<VideoFrame> Provider::grab(uint32_t timeoutInMs) { return m_imp->grab(timeoutInMs); }
+std::shared_ptr<VideoFrame> Provider::grab(uint32_t timeoutInMs) {
+    if (!m_imp) {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::PROVIDER_IMPLEMENTATION_NULL);
+        return nullptr;
+    }
+    return m_imp->grab(timeoutInMs);
+}
 
 void Provider::setNewFrameCallback(std::function<bool(const std::shared_ptr<VideoFrame>&)> callback) {
+    if (!m_imp) {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::PROVIDER_IMPLEMENTATION_NULL);
+        return;
+    }
     m_imp->setNewFrameCallback(std::move(callback));
 }
 
 void Provider::setFrameAllocator(std::function<std::shared_ptr<Allocator>()> allocatorFactory) {
+    if (!m_imp) {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::PROVIDER_IMPLEMENTATION_NULL);
+        return;
+    }
     m_imp->setFrameAllocator(std::move(allocatorFactory));
 }
 
-void Provider::setMaxAvailableFrameSize(uint32_t size) { m_imp->setMaxAvailableFrameSize(size); }
+void Provider::setMaxAvailableFrameSize(uint32_t size) {
+    if (!m_imp) {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::PROVIDER_IMPLEMENTATION_NULL);
+        return;
+    }
+    m_imp->setMaxAvailableFrameSize(size);
+}
 
-void Provider::setMaxCacheFrameSize(uint32_t size) { m_imp->setMaxCacheFrameSize(size); }
+void Provider::setMaxCacheFrameSize(uint32_t size) {
+    if (!m_imp) {
+        ccap::reportError(ErrorCode::InitializationFailed, ErrorMessages::PROVIDER_IMPLEMENTATION_NULL);
+        return;
+    }
+    m_imp->setMaxCacheFrameSize(size);
+}
 
-} // namespace ccap
+} // namespace ccap
diff --git a/src/ccap_imp.cpp b/src/ccap_imp.cpp
@@ -111,6 +111,7 @@ std::shared_ptr<VideoFrame> ProviderImp::grab(uint32_t timeoutInMs) {
     if (m_availableFrames.empty() && timeoutInMs > 0) {
         if (!isStarted()) {
             CCAP_LOG_W("ccap: Grab called when camera is not started!");
+            ccap::reportError(ErrorCode::DeviceStartFailed, "Grab called when camera is not started");
             return nullptr;
         }
 
@@ -127,6 +128,7 @@ std::shared_ptr<VideoFrame> ProviderImp::grab(uint32_t timeoutInMs) {
         m_grabFrameWaiting = false;
         if (!waitSuccess) {
             CCAP_LOG_V("ccap: Grab timed out after %u ms\n", timeoutInMs);
+            ccap::reportError(ErrorCode::FrameCaptureTimeout, "Grab timed out after " + std::to_string(timeoutInMs) + " ms");
             return nullptr;
         }
     }
@@ -198,4 +200,4 @@ void reportError(ErrorCode errorCode, std::string_view description) {
     }
 }
 
-} // namespace ccap
+} // namespace ccap
diff --git a/src/ccap_imp.h b/src/ccap_imp.h
@@ -32,6 +32,7 @@
 #endif
 
 namespace ccap {
+
 struct FrameProperty {
     double fps{ 0.0 }; ///< 0 means device default.
 
@@ -131,6 +132,12 @@ inline bool operator&(PixelFormat lhs, PixelFormatConstants rhs) { return (stati
 
 void reportError(ErrorCode errorCode, std::string_view description);
 
+// Common error messages
+namespace ErrorMessages {
+constexpr const char* PROVIDER_IMPLEMENTATION_NULL = "Provider implementation is null";
+constexpr const char* FAILED_TO_CREATE_PROVIDER = "Failed to create provider implementation";
+} // namespace ErrorMessages
+
 } // namespace ccap
 
-#endif
+#endif
diff --git a/src/ccap_imp_apple.mm b/src/ccap_imp_apple.mm
@@ -298,6 +298,7 @@ - (BOOL)open {
 
         if (![_session canSetSessionPreset:preset]) {
             CCAP_NSLOG_E(@"ccap: CameraCaptureObjc init - session preset not supported, using AVCaptureSessionPresetHigh");
+            ccap::reportError(ErrorCode::UnsupportedResolution, "Session preset not supported");
             preset = AVCaptureSessionPresetHigh;
         }
 
@@ -644,6 +645,7 @@ - (void)setFrameRate:(double)fps {
                     }
                 } else {
                     CCAP_NSLOG_E(@"ccap: Desired fps (%g) not supported, skipping", fps);
+                    ccap::reportError(ErrorCode::FrameRateSetFailed, "Desired fps not supported");
                 }
             }
         } else {
@@ -1037,6 +1039,7 @@ - (void)captureOutput:(AVCaptureOutput*)output
 bool ProviderApple::start() {
     if (!isOpened()) {
         CCAP_NSLOG_W(@"ccap: camera start called with no device opened");
+        ccap::reportError(ErrorCode::DeviceStartFailed, "Camera start called with no device opened");
         return false;
     }
 
@@ -1059,4 +1062,4 @@ - (void)captureOutput:(AVCaptureOutput*)output
 
 } // namespace ccap
 
-#endif
+#endif
diff --git a/src/ccap_imp_linux.cpp b/src/ccap_imp_linux.cpp
@@ -126,7 +126,7 @@ bool ProviderV4L2::open(std::string_view deviceName) {
     if (!setupDevice()) {
         ::close(m_fd);
         m_fd = -1;
-        reportError(ErrorCode::DeviceOpenFailed, "Failed to setup device " + m_devicePath);
+        ccap::reportError(ErrorCode::DeviceOpenFailed, "Failed to setup device " + m_devicePath);
         return false;
     }
 
@@ -187,7 +187,7 @@ bool ProviderV4L2::start() {
     }
 
     if (!negotiateFormat() || !allocateBuffers() || !startStreaming()) {
-        reportError(ErrorCode::DeviceStartFailed, "Failed to start streaming");
+        ccap::reportError(ErrorCode::DeviceStartFailed, "Failed to start streaming");
         return false;
     }
 
@@ -451,6 +451,7 @@ void ProviderV4L2::stopStreaming() {
     enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     if (ioctl(m_fd, VIDIOC_STREAMOFF, &type) < 0) {
         CCAP_LOG_E("ccap: VIDIOC_STREAMOFF failed: %s\n", strerror(errno));
+        ccap::reportError(ErrorCode::DeviceStopFailed, "VIDIOC_STREAMOFF failed: " + std::string(strerror(errno)));
     }
 }
 
@@ -636,6 +637,7 @@ bool ProviderV4L2::readFrame() {
 
                 if (ioctl(m_fd, VIDIOC_QBUF, &requeueBuf) < 0) {
                     CCAP_LOG_E("ccap: VIDIOC_QBUF failed in destructor: %s\n", strerror(errno));
+                    ccap::reportError(ErrorCode::FrameCaptureFailed, "VIDIOC_QBUF failed in destructor: " + std::string(strerror(errno)));
                 }
             }
             frame = nullptr;
@@ -651,6 +653,7 @@ bool ProviderV4L2::readFrame() {
         // Requeue buffer immediately after copying data
         if (ioctl(m_fd, VIDIOC_QBUF, &buf) < 0) {
             CCAP_LOG_E("ccap: VIDIOC_QBUF failed: %s\n", strerror(errno));
+            ccap::reportError(ErrorCode::FrameCaptureFailed, "VIDIOC_QBUF failed: " + std::string(strerror(errno)));
             return false;
         }
     }
diff --git a/src/ccap_imp_windows.cpp b/src/ccap_imp_windows.cpp
@@ -589,6 +589,7 @@ bool ProviderDirectShow::createStream() {
                 }
             } else {
                 CCAP_LOG_E("ccap: SetFormat failed, result=0x%lx\n", setFormatResult);
+                ccap::reportError(ErrorCode::UnsupportedPixelFormat, "SetFormat failed");
             }
         }
     }
@@ -623,6 +624,7 @@ bool ProviderDirectShow::createStream() {
         hr = m_graph->QueryInterface(IID_IMediaFilter, (void**)&pMediaFilter);
         if (FAILED(hr)) {
             CCAP_LOG_E("ccap: QueryInterface IMediaFilter failed, result=0x%lx\n", hr);
+            ccap::reportError(ErrorCode::DeviceOpenFailed, "QueryInterface IMediaFilter failed");
         } else {
             pMediaFilter->SetSyncSource(NULL);
             pMediaFilter->Release();
@@ -686,11 +688,12 @@ bool ProviderDirectShow::open(std::string_view deviceName) {
     CCAP_LOG_I("ccap: Found video capture device: %s\n", m_deviceName.c_str());
 
     if (!buildGraph()) {
-        reportError(ErrorCode::DeviceOpenFailed, "Failed to build DirectShow graph");
+        ccap::reportError(ErrorCode::DeviceOpenFailed, "Failed to build DirectShow graph");
         return false;
     }
 
     if (!createStream()) {
+        ccap::reportError(ErrorCode::DeviceOpenFailed, "Failed to create DirectShow stream");
         return false;
     }
 
@@ -706,7 +709,8 @@ bool ProviderDirectShow::open(std::string_view deviceName) {
         hr = m_graph->QueryInterface(IID_IVideoWindow, (LPVOID*)&videoWindow);
         if (FAILED(hr)) {
             CCAP_LOG_E("ccap: QueryInterface IVideoWindow failed, result=0x%lx\n", hr);
-            return hr;
+            ccap::reportError(ErrorCode::DeviceOpenFailed, "QueryInterface IVideoWindow failed");
+            return false;
         }
         videoWindow->put_AutoShow(false);
     }
@@ -732,6 +736,7 @@ HRESULT STDMETHODCALLTYPE ProviderDirectShow::SampleCB(double sampleTime, IMedia
     BYTE* sampleData = nullptr;
     if (auto hr = mediaSample->GetPointer(&sampleData); FAILED(hr)) {
         CCAP_LOG_E("ccap: GetPointer failed, hr=0x%lx\n", hr);
+        ccap::reportError(ErrorCode::FrameCaptureFailed, "GetPointer failed");
         return S_OK;
     }
 
@@ -1069,4 +1074,4 @@ bool ProviderDirectShow::isStarted() const { return m_isRunning && m_mediaContro
 ProviderImp* createProviderDirectShow() { return new ProviderDirectShow(); }
 
 } // namespace ccap
-#endif
+#endif
diff --git a/src/ccap_utils.cpp b/src/ccap_utils.cpp
@@ -261,6 +261,8 @@ std::string_view errorCodeToString(ErrorCode errorCode) {
         return "Camera start failed";
     case ErrorCode::DeviceStopFailed:
         return "Camera stop failed";
+    case ErrorCode::InitializationFailed:
+        return "Initialization failed";
     case ErrorCode::UnsupportedResolution:
         return "Requested resolution is not supported";
     case ErrorCode::UnsupportedPixelFormat:
@@ -282,4 +284,4 @@ std::string_view errorCodeToString(ErrorCode errorCode) {
     }
 }
 
-} // namespace ccap
+} // namespace ccap

Original file line number	Diff line number	Diff line change
`@@ -111,6 +111,7 @@ std::shared_ptr<VideoFrame> ProviderImp::grab(uint32_t timeoutInMs) {`
`111`	`111`	`if (m_availableFrames.empty() && timeoutInMs > 0) {`
`112`	`112`	`if (!isStarted()) {`
`113`	`113`	`CCAP_LOG_W("ccap: Grab called when camera is not started!");`
	`114`	`+ ccap::reportError(ErrorCode::DeviceStartFailed, "Grab called when camera is not started");`
`114`	`115`	`return nullptr;`
`115`	`116`	`}`
`116`	`117`
`@@ -127,6 +128,7 @@ std::shared_ptr<VideoFrame> ProviderImp::grab(uint32_t timeoutInMs) {`
`127`	`128`	`m_grabFrameWaiting = false;`
`128`	`129`	`if (!waitSuccess) {`
`129`	`130`	`CCAP_LOG_V("ccap: Grab timed out after %u ms\n", timeoutInMs);`
	`131`	`+ ccap::reportError(ErrorCode::FrameCaptureTimeout, "Grab timed out after " + std::to_string(timeoutInMs) + " ms");`
`130`	`132`	`return nullptr;`
`131`	`133`	`}`
`132`	`134`	`}`
`@@ -198,4 +200,4 @@ void reportError(ErrorCode errorCode, std::string_view description) {`
`198`	`200`	`}`
`199`	`201`	`}`
`200`	`202`
`201`		`-} // namespace ccap`
	`203`	`+} // namespace ccap`
Original file line number	Diff line number	Diff line change
`@@ -298,6 +298,7 @@ - (BOOL)open {`
`298`	`298`
`299`	`299`	`if (![_session canSetSessionPreset:preset]) {`
`300`	`300`	`CCAP_NSLOG_E(@"ccap: CameraCaptureObjc init - session preset not supported, using AVCaptureSessionPresetHigh");`
	`301`	`+ ccap::reportError(ErrorCode::UnsupportedResolution, "Session preset not supported");`
`301`	`302`	`preset = AVCaptureSessionPresetHigh;`
`302`	`303`	`}`
`303`	`304`
`@@ -644,6 +645,7 @@ - (void)setFrameRate:(double)fps {`
`644`	`645`	`}`
`645`	`646`	`} else {`
`646`	`647`	`CCAP_NSLOG_E(@"ccap: Desired fps (%g) not supported, skipping", fps);`
	`648`	`+ ccap::reportError(ErrorCode::FrameRateSetFailed, "Desired fps not supported");`
`647`	`649`	`}`
`648`	`650`	`}`
`649`	`651`	`} else {`
`@@ -1037,6 +1039,7 @@ - (void)captureOutput:(AVCaptureOutput*)output`
`1037`	`1039`	`bool ProviderApple::start() {`
`1038`	`1040`	`if (!isOpened()) {`
`1039`	`1041`	`CCAP_NSLOG_W(@"ccap: camera start called with no device opened");`
	`1042`	`+ ccap::reportError(ErrorCode::DeviceStartFailed, "Camera start called with no device opened");`
`1040`	`1043`	`return false;`
`1041`	`1044`	`}`
`1042`	`1045`
`@@ -1059,4 +1062,4 @@ - (void)captureOutput:(AVCaptureOutput*)output`
`1059`	`1062`
`1060`	`1063`	`} // namespace ccap`
`1061`	`1064`
`1062`		`-#endif`
	`1065`	`+#endif`
Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,7 @@ bool ProviderV4L2::open(std::string_view deviceName) {`
`126`	`126`	`if (!setupDevice()) {`
`127`	`127`	`::close(m_fd);`
`128`	`128`	`m_fd = -1;`
`129`		`- reportError(ErrorCode::DeviceOpenFailed, "Failed to setup device " + m_devicePath);`
	`129`	`+ ccap::reportError(ErrorCode::DeviceOpenFailed, "Failed to setup device " + m_devicePath);`
`130`	`130`	`return false;`
`131`	`131`	`}`
`132`	`132`
`@@ -187,7 +187,7 @@ bool ProviderV4L2::start() {`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`if (!negotiateFormat() \|\| !allocateBuffers() \|\| !startStreaming()) {`
`190`		`- reportError(ErrorCode::DeviceStartFailed, "Failed to start streaming");`
	`190`	`+ ccap::reportError(ErrorCode::DeviceStartFailed, "Failed to start streaming");`
`191`	`191`	`return false;`
`192`	`192`	`}`
`193`	`193`
`@@ -451,6 +451,7 @@ void ProviderV4L2::stopStreaming() {`
`451`	`451`	`enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;`
`452`	`452`	`if (ioctl(m_fd, VIDIOC_STREAMOFF, &type) < 0) {`
`453`	`453`	`CCAP_LOG_E("ccap: VIDIOC_STREAMOFF failed: %s\n", strerror(errno));`
	`454`	`+ ccap::reportError(ErrorCode::DeviceStopFailed, "VIDIOC_STREAMOFF failed: " + std::string(strerror(errno)));`
`454`	`455`	`}`
`455`	`456`	`}`
`456`	`457`
`@@ -636,6 +637,7 @@ bool ProviderV4L2::readFrame() {`
`636`	`637`
`637`	`638`	`if (ioctl(m_fd, VIDIOC_QBUF, &requeueBuf) < 0) {`
`638`	`639`	`CCAP_LOG_E("ccap: VIDIOC_QBUF failed in destructor: %s\n", strerror(errno));`
	`640`	`+ ccap::reportError(ErrorCode::FrameCaptureFailed, "VIDIOC_QBUF failed in destructor: " + std::string(strerror(errno)));`
`639`	`641`	`}`
`640`	`642`	`}`
`641`	`643`	`frame = nullptr;`
`@@ -651,6 +653,7 @@ bool ProviderV4L2::readFrame() {`
`651`	`653`	`// Requeue buffer immediately after copying data`
`652`	`654`	`if (ioctl(m_fd, VIDIOC_QBUF, &buf) < 0) {`
`653`	`655`	`CCAP_LOG_E("ccap: VIDIOC_QBUF failed: %s\n", strerror(errno));`
	`656`	`+ ccap::reportError(ErrorCode::FrameCaptureFailed, "VIDIOC_QBUF failed: " + std::string(strerror(errno)));`
`654`	`657`	`return false;`
`655`	`658`	`}`
`656`	`659`	`}`
Original file line number	Diff line number	Diff line change
`@@ -589,6 +589,7 @@ bool ProviderDirectShow::createStream() {`
`589`	`589`	`}`
`590`	`590`	`} else {`
`591`	`591`	`CCAP_LOG_E("ccap: SetFormat failed, result=0x%lx\n", setFormatResult);`
	`592`	`+ ccap::reportError(ErrorCode::UnsupportedPixelFormat, "SetFormat failed");`
`592`	`593`	`}`
`593`	`594`	`}`
`594`	`595`	`}`
`@@ -623,6 +624,7 @@ bool ProviderDirectShow::createStream() {`
`623`	`624`	`hr = m_graph->QueryInterface(IID_IMediaFilter, (void**)&pMediaFilter);`
`624`	`625`	`if (FAILED(hr)) {`
`625`	`626`	`CCAP_LOG_E("ccap: QueryInterface IMediaFilter failed, result=0x%lx\n", hr);`
	`627`	`+ ccap::reportError(ErrorCode::DeviceOpenFailed, "QueryInterface IMediaFilter failed");`
`626`	`628`	`} else {`
`627`	`629`	`pMediaFilter->SetSyncSource(NULL);`
`628`	`630`	`pMediaFilter->Release();`
`@@ -686,11 +688,12 @@ bool ProviderDirectShow::open(std::string_view deviceName) {`
`686`	`688`	`CCAP_LOG_I("ccap: Found video capture device: %s\n", m_deviceName.c_str());`
`687`	`689`
`688`	`690`	`if (!buildGraph()) {`
`689`		`- reportError(ErrorCode::DeviceOpenFailed, "Failed to build DirectShow graph");`
	`691`	`+ ccap::reportError(ErrorCode::DeviceOpenFailed, "Failed to build DirectShow graph");`
`690`	`692`	`return false;`
`691`	`693`	`}`
`692`	`694`
`693`	`695`	`if (!createStream()) {`
	`696`	`+ ccap::reportError(ErrorCode::DeviceOpenFailed, "Failed to create DirectShow stream");`
`694`	`697`	`return false;`
`695`	`698`	`}`
`696`	`699`
`@@ -706,7 +709,8 @@ bool ProviderDirectShow::open(std::string_view deviceName) {`
`706`	`709`	`hr = m_graph->QueryInterface(IID_IVideoWindow, (LPVOID*)&videoWindow);`
`707`	`710`	`if (FAILED(hr)) {`
`708`	`711`	`CCAP_LOG_E("ccap: QueryInterface IVideoWindow failed, result=0x%lx\n", hr);`
`709`		`- return hr;`
	`712`	`+ ccap::reportError(ErrorCode::DeviceOpenFailed, "QueryInterface IVideoWindow failed");`
	`713`	`+ return false;`
`710`	`714`	`}`
`711`	`715`	`videoWindow->put_AutoShow(false);`
`712`	`716`	`}`
`@@ -732,6 +736,7 @@ HRESULT STDMETHODCALLTYPE ProviderDirectShow::SampleCB(double sampleTime, IMedia`
`732`	`736`	`BYTE* sampleData = nullptr;`
`733`	`737`	`if (auto hr = mediaSample->GetPointer(&sampleData); FAILED(hr)) {`
`734`	`738`	`CCAP_LOG_E("ccap: GetPointer failed, hr=0x%lx\n", hr);`
	`739`	`+ ccap::reportError(ErrorCode::FrameCaptureFailed, "GetPointer failed");`
`735`	`740`	`return S_OK;`
`736`	`741`	`}`
`737`	`742`
`@@ -1069,4 +1074,4 @@ bool ProviderDirectShow::isStarted() const { return m_isRunning && m_mediaContro`
`1069`	`1074`	`ProviderImp* createProviderDirectShow() { return new ProviderDirectShow(); }`
`1070`	`1075`
`1071`	`1076`	`} // namespace ccap`
`1072`		`-#endif`
	`1077`	`+#endif`
Original file line number	Diff line number	Diff line change
`@@ -261,6 +261,8 @@ std::string_view errorCodeToString(ErrorCode errorCode) {`
`261`	`261`	`return "Camera start failed";`
`262`	`262`	`case ErrorCode::DeviceStopFailed:`
`263`	`263`	`return "Camera stop failed";`
	`264`	`+ case ErrorCode::InitializationFailed:`
	`265`	`+ return "Initialization failed";`
`264`	`266`	`case ErrorCode::UnsupportedResolution:`
`265`	`267`	`return "Requested resolution is not supported";`
`266`	`268`	`case ErrorCode::UnsupportedPixelFormat:`
`@@ -282,4 +284,4 @@ std::string_view errorCodeToString(ErrorCode errorCode) {`
`282`	`284`	`}`
`283`	`285`	`}`
`284`	`286`
`285`		`-} // namespace ccap`
	`287`	`+} // namespace ccap`