Feature/rdkemw 12692

media/client/ipc/include/MediaPipelineIpc.h

@@ -93,6 +93,8 @@ class MediaPipelineIpc : public IMediaPipelineIpc, public IpcModule
 
     bool setImmediateOutput(int32_t sourceId, bool immediateOutput) override;
 
+    bool setReportDecodeErrors(int32_t sourceId, bool reportDecodeErrors) override;
+
     bool getImmediateOutput(int32_t sourceId, bool &immediateOutput) override;
 
     bool getStats(int32_t sourceId, uint64_t &renderedFrames, uint64_t &droppedFrames) override;

media/client/ipc/interface/IMediaPipelineIpc.h

@@ -188,6 +188,18 @@ class IMediaPipelineIpc
      */
     virtual bool setImmediateOutput(int32_t sourceId, bool immediateOutput) = 0;
 
+    /**
+     * @brief Sets the "Report Decode Errors" property for this source.
+     *
+     * This method is asynchronous, it will set the "Report Decode Errors" property
+     *
+     * @param[in] sourceId  : The source id. Value should be set to the MediaSource.id returned after attachSource()
+     * @param[in] immediateOutput : Set Report Decode Errors mode on the sink
+     *
+     * @retval true on success.
+     */
+    virtual bool setReportDecodeErrors(int32_t sourceId, bool reportDecodeErrors) = 0;
+
     /**
      * @brief Gets the "Immediate Output" property for this source.
      *

media/client/ipc/source/MediaPipelineIpc.cpp

@@ -567,6 +567,38 @@ bool MediaPipelineIpc::setImmediateOutput(int32_t sourceId, bool immediateOutput
     return true;
 }
 
+bool MediaPipelineIpc::setReportDecodeErrors(int32_t sourceId, bool reportDecodeErrors)
+{
+    if (!reattachChannelIfRequired())
+    {
+        RIALTO_CLIENT_LOG_ERROR("Reattachment of the ipc channel failed, ipc disconnected");
+        return false;
+    }
+
+    firebolt::rialto::ReportDecodeErrorsRequest request;
+
+    request.set_session_id(m_sessionId);
+    request.set_source_id(sourceId);
+    request.set_report_decode_errors(reportDecodeErrors);
+
+    firebolt::rialto::ReportDecodeErrorsResponse response;
+    auto ipcController = m_ipc.createRpcController();
+    auto blockingClosure = m_ipc.createBlockingClosure();
+    m_mediaPipelineStub->setReportDecodeErrors(ipcController.get(), &request, &response, blockingClosure.get());
+
+    // wait for the call to complete
+    blockingClosure->wait();
+
+    // check the result
+    if (ipcController->Failed())
+    {
+        RIALTO_CLIENT_LOG_ERROR("failed to set report decode error due to '%s'", ipcController->ErrorText().c_str());
+        return false;
+    }
+
+    return true;
+}
+
 bool MediaPipelineIpc::getImmediateOutput(int32_t sourceId, bool &immediateOutput)
 {
     if (!reattachChannelIfRequired())

media/client/main/include/MediaPipeline.h

@@ -132,6 +132,8 @@ class MediaPipeline : public IMediaPipelineAndIControlClient, public IMediaPipel
 
     bool setImmediateOutput(int32_t sourceId, bool immediateOutput) override;
 
+    bool setReportDecodeErrors(int32_t sourceId, bool reportDecodeErrors) override;
+
     bool getImmediateOutput(int32_t sourceId, bool &immediateOutput) override;
 
     bool getStats(int32_t sourceId, uint64_t &renderedFrames, uint64_t &droppedFrames) override;

media/client/main/include/MediaPipelineProxy.h

@@ -68,6 +68,10 @@ class MediaPipelineProxy : public IMediaPipelineAndIControlClient
     {
         return m_mediaPipeline->setImmediateOutput(sourceId, immediateOutput);
     }
+    bool setReportDecodeErrors(int32_t sourceId, bool reportDecodeErrors)
+    {
+        return m_mediaPipeline->setReportDecodeErrors(sourceId, reportDecodeErrors);
+    }
     bool getImmediateOutput(int32_t sourceId, bool &immediateOutput)
     {
         return m_mediaPipeline->getImmediateOutput(sourceId, immediateOutput);

media/client/main/source/MediaPipeline.cpp

@@ -313,6 +313,11 @@ bool MediaPipeline::setImmediateOutput(int32_t sourceId, bool immediateOutput)
     return m_mediaPipelineIpc->setImmediateOutput(sourceId, immediateOutput);
 }
 
+bool MediaPipeline::setReportDecodeErrors(int32_t sourceId, bool reportDecodeErrors)
+{
+    return m_mediaPipelineIpc->setReportDecodeErrors(sourceId, reportDecodeErrors);
+}
+
 bool MediaPipeline::getImmediateOutput(int32_t sourceId, bool &immediateOutput)
 {
     return m_mediaPipelineIpc->getImmediateOutput(sourceId, immediateOutput);

media/public/include/IMediaPipeline.h

@@ -1227,6 +1227,18 @@ class IMediaPipeline
      */
     virtual bool setImmediateOutput(int32_t sourceId, bool immediateOutput) = 0;
 
+    /**
+     * @brief Sets the "Report Decode Errors" property for this source.
+     *
+     * This method is asynchronous, it will set the "Report Decode Errors" property
+     *
+     * @param[in] sourceId  : The source id. Value should be set to the MediaSource.id returned after attachSource()
+     * @param[in] immediateOutput : Set Report Decode Errors mode on the sink
+     *
+     * @retval true on success.
+     */
+    virtual bool setReportDecodeErrors(int32_t sourceId, bool reportDecodeErrors) = 0;
+
     /**
      * @brief Gets the "Immediate Output" property for this source.
      *

media/server/gstplayer/CMakeLists.txt

@@ -58,6 +58,7 @@ add_library(
         source/tasks/generic/SetMute.cpp
         source/tasks/generic/SetPlaybackRate.cpp
         source/tasks/generic/SetPosition.cpp
+        source/tasks/generic/SetReportDecodeErrors.cpp
         source/tasks/generic/SetSourcePosition.cpp
         source/tasks/generic/SetSubtitleOffset.cpp
         source/tasks/generic/SetStreamSyncMode.cpp

media/server/gstplayer/include/GstGenericPlayer.h

@@ -120,6 +120,7 @@ class GstGenericPlayer : public IGstGenericPlayer, public IGstGenericPlayerPriva
     void setPlaybackRate(double rate) override;
     bool getPosition(std::int64_t &position) override;
     bool setImmediateOutput(const MediaSourceType &mediaSourceType, bool immediateOutput) override;
+    bool setReportDecodeErrors(const MediaSourceType &mediaSourceType, bool reportDecodeErrors) override;
     bool getImmediateOutput(const MediaSourceType &mediaSourceType, bool &immediateOutput) override;
     bool getStats(const MediaSourceType &mediaSourceType, uint64_t &renderedFrames, uint64_t &droppedFrames) override;
     void setVolume(double targetVolume, uint32_t volumeDuration, firebolt::rialto::EaseType easeType) override;
@@ -154,6 +155,7 @@ class GstGenericPlayer : public IGstGenericPlayer, public IGstGenericPlayerPriva
     void scheduleAllSourcesAttached() override;
     bool setVideoSinkRectangle() override;
     bool setImmediateOutput() override;
+    bool setReportDecodeErrors(bool reportDecodeErrors) override;
     bool setShowVideoWindow() override;
     bool setLowLatency() override;
     bool setSync() override;

media/server/gstplayer/include/IGstGenericPlayerPrivate.h

@@ -80,6 +80,13 @@ class IGstGenericPlayerPrivate
      */
     virtual bool setImmediateOutput() = 0;
 
+    /**
+     * @brief Sets report decode error. Called by the worker thread.
+     *
+     * @retval true on success.
+     */
+    virtual bool setReportDecodeErrors(bool reportDecodeErrors) = 0;
+
     /**
      * @brief Sets the low latency property. Called by the worker thread.
      *

media/server/gstplayer/include/tasks/IGenericPlayerTaskFactory.h

@@ -494,6 +494,21 @@ class IGenericPlayerTaskFactory
                                                                   const firebolt::rialto::MediaSourceType &type,
                                                                   bool immediateOutput) const = 0;
 
+    /**
+     * @brief Creates a setReportDecodeErrors task.
+     *
+     * @param[in] context         : The GstPlayer context
+     * @param[in] player          : The GstPlayer instance
+     * @param[in] type            : The media source type
+     * @param[in] immediateOutput : the value to set for report decode error
+     *
+     * @retval the new ProcessAudioGap task instance.
+     */
+    virtual std::unique_ptr<IPlayerTask> createSetReportDecodeErrors(GenericPlayerContext &context,
+                                                                  IGstGenericPlayerPrivate &player,
+                                                                  const firebolt::rialto::MediaSourceType &type,
+                                                                  bool reportDecodeErrors) const = 0;
+
     /**
      * @brief Creates a SetBufferingLimit task.
      *

media/server/gstplayer/include/tasks/generic/GenericPlayerTaskFactory.h

@@ -122,6 +122,9 @@ class GenericPlayerTaskFactory : public IGenericPlayerTaskFactory
     std::unique_ptr<IPlayerTask> createSetImmediateOutput(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
                                                           const firebolt::rialto::MediaSourceType &type,
                                                           bool immediateOutput) const override;
+    std::unique_ptr<IPlayerTask> createSetReportDecodeErrors(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
+                                                          const firebolt::rialto::MediaSourceType &type,
+                                                          bool reportDecodeErrors) const override;
     std::unique_ptr<IPlayerTask> createSetBufferingLimit(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
                                                          std::uint32_t limit) const override;
     std::unique_ptr<IPlayerTask> createSetUseBuffering(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,

media/server/gstplayer/include/tasks/generic/SetReportDecodeErrors.h

@@ -0,0 +1,49 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2024 Sky UK
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FIREBOLT_RIALTO_SERVER_TASKS_GENERIC_SET_REPORT_DECODE_ERROR_H_
+#define FIREBOLT_RIALTO_SERVER_TASKS_GENERIC_SET_REPORT_DECODE_ERROR_H_
+
+#include "GenericPlayerContext.h"
+#include "IGlibWrapper.h"
+#include "IGstGenericPlayerPrivate.h"
+#include "IGstWrapper.h"
+#include "IPlayerTask.h"
+
+#include <memory>
+
+namespace firebolt::rialto::server::tasks::generic
+{
+class SetReportDecodeErrors : public IPlayerTask
+{
+public:
+    explicit SetReportDecodeErrors(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
+                                const MediaSourceType &type, bool reportDecodeErrors);
+    ~SetReportDecodeErrors() override;
+    void execute() const override;
+
+private:
+    GenericPlayerContext &m_context;
+    IGstGenericPlayerPrivate &m_player;
+    const MediaSourceType m_type;
+    bool m_reportDecodeErrors;
+};
+} // namespace firebolt::rialto::server::tasks::generic
+
+#endif // FIREBOLT_RIALTO_SERVER_TASKS_GENERIC_SET_REPORT_DECODE_ERROR_H_

media/server/gstplayer/interface/IGstGenericPlayer.h

@@ -204,6 +204,16 @@ class IGstGenericPlayer
      */
     virtual bool setImmediateOutput(const MediaSourceType &mediaSourceType, bool immediateOutput) = 0;
 
+    /**
+     * @brief Sets the "Report Decode Error" property for this source.
+     *
+     * @param[in] mediaSourceType : The media source type
+     * @param[in] reportDecodeErrors : Set report decode error
+     *
+     * @retval true on success.
+     */
+    virtual bool setReportDecodeErrors(const MediaSourceType &mediaSourceType, bool reportDecodeErrors) = 0;
+
     /**
      * @brief Gets the "Immediate Output" property for this source.
      *

media/server/gstplayer/source/GstGenericPlayer.cpp

@@ -654,6 +654,16 @@ bool GstGenericPlayer::setImmediateOutput(const MediaSourceType &mediaSourceType
     return true;
 }
 
+bool GstGenericPlayer::setReportDecodeErrors(const MediaSourceType &mediaSourceType, bool reportDecodeErrors)
+{
+    if (!m_workerThread)
+        return false;
+
+    m_workerThread->enqueueTask(
+        m_taskFactory->createSetReportDecodeErrors(m_context, *this, mediaSourceType, reportDecodeErrors));
+    return true;
+}
+
 bool GstGenericPlayer::getImmediateOutput(const MediaSourceType &mediaSourceType, bool &immediateOutputRef)
 {
     bool returnValue{false};
@@ -1360,6 +1370,33 @@ bool GstGenericPlayer::setImmediateOutput()
     return result;
 }
 
+bool GstGenericPlayer::setReportDecodeErrors(bool reportDecodeErrors)
+{
+    bool result{false};
+    GstElement *decoder = getDecoder(MediaSourceType::VIDEO);
+    if (decoder)
+    {
+        RIALTO_SERVER_LOG_DEBUG("Set report decode errors to %s", reportDecodeErrors ? "TRUE" : "FALSE");
+
+        if (m_glibWrapper->gObjectClassFindProperty(G_OBJECT_GET_CLASS(decoder), "report_decode_errors"))
+        {
+            gboolean reportDecodeErrorsGboolean{reportDecodeErrors ? TRUE : FALSE};
+            m_glibWrapper->gObjectSet(decoder, "report_decode_errors", reportDecodeErrorsGboolean, nullptr);
+            result = true;
+        }
+        else
+        {
+            RIALTO_SERVER_LOG_ERROR("Failed to set report_decode_errors property on decoder '%s'", GST_ELEMENT_NAME(decoder));
+        }
+        m_gstWrapper->gstObjectUnref(decoder);
+    }
+    else
+    {
+        RIALTO_SERVER_LOG_DEBUG("Pending an report_decode_errors, decoder is NULL");
+    }
+    return result;
+}
+
 bool GstGenericPlayer::setShowVideoWindow()
 {
     if (!m_context.pendingShowVideoWindow.has_value())

media/server/gstplayer/source/tasks/generic/GenericPlayerTaskFactory.cpp

@@ -38,6 +38,7 @@
 #include "tasks/generic/ReportPosition.h"
 #include "tasks/generic/SetBufferingLimit.h"
 #include "tasks/generic/SetImmediateOutput.h"
+#include "tasks/generic/SetReportDecodeErrors.h"
 #include "tasks/generic/SetLowLatency.h"
 #include "tasks/generic/SetMute.h"
 #include "tasks/generic/SetPlaybackRate.h"
@@ -334,6 +335,14 @@ GenericPlayerTaskFactory::createSetImmediateOutput(GenericPlayerContext &context
     return std::make_unique<tasks::generic::SetImmediateOutput>(context, player, type, immediateOutput);
 }
 
+std::unique_ptr<IPlayerTask>
+GenericPlayerTaskFactory::createSetReportDecodeErrors(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
+                                                   const firebolt::rialto::MediaSourceType &type,
+                                                   bool reportDecodeErrors) const
+{
+    return std::make_unique<tasks::generic::SetReportDecodeErrors>(context, player, type, reportDecodeErrors);
+}
+
 std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetBufferingLimit(GenericPlayerContext &context,
                                                                                IGstGenericPlayerPrivate &player,
                                                                                std::uint32_t limit) const

media/server/gstplayer/source/tasks/generic/SetReportDecodeErrors.cpp

@@ -0,0 +1,52 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2024 Sky UK
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SetReportDecodeErrors.h"
+#include "RialtoServerLogging.h"
+#include "TypeConverters.h"
+
+namespace firebolt::rialto::server::tasks::generic
+{
+SetReportDecodeErrors::SetReportDecodeErrors(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
+                                       const MediaSourceType &type, bool reportDecodeErrors)
+    : m_context{context}, m_player(player), m_type{type}, m_reportDecodeErrors{reportDecodeErrors}
+{
+    RIALTO_SERVER_LOG_DEBUG("Constructing SetReportDecodeErrors");
+}
+
+SetReportDecodeErrors::~SetReportDecodeErrors()
+{
+    RIALTO_SERVER_LOG_DEBUG("SetReportDecodeErrors finished");
+}
+
+void SetReportDecodeErrors::execute() const
+{
+    RIALTO_SERVER_LOG_DEBUG("Executing SetReportDecodeErrors for %s source", common::convertMediaSourceType(m_type));
+
+    if (m_type != MediaSourceType::VIDEO)
+    {
+        RIALTO_SERVER_LOG_ERROR("SetReportDecodeErrors not currently supported for non-video");
+    }
+
+    if (m_context.pipeline)
+    {
+        m_player.setReportDecodeErrors(m_reportDecodeErrors);
+    }
+}
+} // namespace firebolt::rialto::server::tasks::generic

media/server/ipc/include/MediaPipelineModuleService.h

@@ -88,6 +88,10 @@ class MediaPipelineModuleService : public IMediaPipelineModuleService
                             const ::firebolt::rialto::SetImmediateOutputRequest *request,
                             ::firebolt::rialto::SetImmediateOutputResponse *response,
                             ::google::protobuf::Closure *done) override;
+    void setReportDecodeErrors(::google::protobuf::RpcController *controller,
+                            const ::firebolt::rialto::ReportDecodeErrorsRequest *request,
+                            ::firebolt::rialto::ReportDecodeErrorsResponse *response,
+                            ::google::protobuf::Closure *done) override;
     void getImmediateOutput(::google::protobuf::RpcController *controller,
                             const ::firebolt::rialto::GetImmediateOutputRequest *request,
                             ::firebolt::rialto::GetImmediateOutputResponse *response,