Support Widevine

Signed-off-by: kkkuangzh <[email protected]>

Author: kkkuangzh

c2_buffers/include/mfx_c2_bitstream_in.h

@@ -40,7 +40,7 @@ class MfxC2BitstreamIn
     // Maps c2 linear block and can leave it in mapped state until
     // frame_view freed or frame_view->Release is called.
     virtual c2_status_t AppendFrame(const C2FrameData& buf_pack, c2_nsecs_t timeout,
-        std::unique_ptr<C2ReadView>* view);
+        std::unique_ptr<C2ReadView>* view, bool header);
 
     virtual bool IsInReset();
 protected: // variables

c2_buffers/src/mfx_c2_bitstream_in.cpp

@@ -82,20 +82,33 @@ c2_status_t MfxC2BitstreamIn::Unload()
 
 
 c2_status_t MfxC2BitstreamIn::AppendFrame(const C2FrameData& buf_pack, c2_nsecs_t timeout,
-    std::unique_ptr<C2ReadView>* frame_view)
+    std::unique_ptr<C2ReadView>* frame_view, bool header)
 {
     MFX_DEBUG_TRACE_FUNC;
 
     c2_status_t res = C2_OK;
     const mfxU8* data = nullptr;
     mfxU32 filled_len = 0;
+    const mfxU8* infobuffer = nullptr;
+    std::unique_ptr<C2ReadView> bs_read_view;
 
+    MFX_DEBUG_TRACE_I32(header);
     do {
         if (!frame_view) {
             res = C2_BAD_VALUE;
             break;
         }
 
+        for (auto &infoBuffer: buf_pack.infoBuffers) {
+            if (infoBuffer.index().typeIndex() == kParamIndexEncryptedBuffer) {
+                const C2BufferData& buf_data = infoBuffer.data();
+                C2ConstLinearBlock encryptedBlock = buf_data.linearBlocks().front();
+                MapConstLinearBlock(encryptedBlock, timeout, &bs_read_view);
+                infobuffer = bs_read_view->data() + encryptedBlock.offset();
+                MFX_DEBUG_TRACE_STREAM("c2 infobuffer data: " << FormatHex(infobuffer, encryptedBlock.size()));
+            }
+        }
+
         if (buf_pack.buffers.size() == 0) {
             m_frameConstructor->SetEosMode(buf_pack.flags & C2FrameData::FLAG_END_OF_STREAM);
             break;
@@ -118,16 +131,28 @@ c2_status_t MfxC2BitstreamIn::AppendFrame(const C2FrameData& buf_pack, c2_nsecs_
 
         m_frameConstructor->SetEosMode(buf_pack.flags & C2FrameData::FLAG_END_OF_STREAM);
 
-        mfxStatus mfx_res = m_frameConstructor->Load(data,
-                                                     filled_len,
-                                                     buf_pack.ordinal.timestamp.peeku(), // pass pts
-                                                     buf_pack.flags & C2FrameData::FLAG_CODEC_CONFIG,
-                                                     true);
+        mfxStatus mfx_res;
+        HUCVideoBuffer *hucBuffer = NULL;
+        hucBuffer = (HUCVideoBuffer *) data;
+        if (hucBuffer->pr_magic == PROTECTED_DATA_BUFFER_MAGIC) {
+             mfx_res = m_frameConstructor->LoadSecure(hucBuffer,
+                                                infobuffer,
+                                                filled_len,
+                                                buf_pack.ordinal.timestamp.peeku(), // pass pts
+                                                header,
+                                                true);
+            *frame_view = std::move(bs_read_view);
+        } else {
+             mfx_res = m_frameConstructor->Load(data,
+                                                filled_len,
+                                                buf_pack.ordinal.timestamp.peeku(), // pass pts
+                                                header,
+                                                true);
+            *frame_view = std::move(read_view);
+        }
         res = MfxStatusToC2(mfx_res);
         if(C2_OK != res) break;
 
-        *frame_view = std::move(read_view);
-
     } while(false);
 
     MFX_DEBUG_TRACE__android_c2_status_t(res);

c2_components/include/mfx_c2_decoder_component.h

@@ -43,6 +43,8 @@ class MfxC2DecoderComponent : public MfxC2Component
         DECODER_VP8,
         DECODER_MPEG2,
         DECODER_AV1,
+        DECODER_H264_SECURE,
+        DECODER_H265_SECURE
     };
 
     enum class OperationState {
@@ -267,6 +269,9 @@ class MfxC2DecoderComponent : public MfxC2Component
     uint32_t m_file_num = 0;
     bool m_needCpuAccess = false;
 
+protected:
+    bool m_secure;
+
     /* -----------------------C2Parameters--------------------------- */
     std::shared_ptr<C2ComponentNameSetting> m_name;
     std::shared_ptr<C2ComponentKindSetting> m_kind;

c2_components/include/mfx_c2_secure_decoder_component.h

@@ -0,0 +1,46 @@
+// Copyright (c) 2017-2024 Intel Corporation
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include "mfx_c2_component.h"
+#include "mfx_c2_decoder_component.h"
+#include "mfx_c2_components_registry.h"
+#include "mfx_dev.h"
+#include "mfx_c2_setters.h"
+#include <cutils/properties.h>
+
+class MfxC2SecureDecoderComponent : public MfxC2DecoderComponent
+{
+public:
+    MfxC2SecureDecoderComponent(const C2String name, const CreateConfig& config,
+        std::shared_ptr<C2ReflectorHelper> reflector, DecoderType decoder_type);
+
+    virtual ~MfxC2SecureDecoderComponent();
+
+    static void RegisterClass(MfxC2ComponentsRegistry& registry);
+
+    MFX_CLASS_NO_COPY(MfxC2SecureDecoderComponent)
+
+private:
+    /* -----------------------C2Parameters--------------------------- */
+    std::shared_ptr<C2SecureModeTuning> m_secureMode;
+};
+

c2_components/src/mfx_c2_components_registry.cpp

@@ -31,6 +31,7 @@
 #else
 #include "mfx_c2_decoder_component.h"
 #include "mfx_c2_encoder_component.h"
+#include "mfx_c2_secure_decoder_component.h"
 #endif
 
 using namespace android;
@@ -65,6 +66,7 @@ MfxC2ComponentsRegistry::MfxC2ComponentsRegistry()
 #else
     MfxC2DecoderComponent::RegisterClass(*this);
     MfxC2EncoderComponent::RegisterClass(*this);
+    MfxC2SecureDecoderComponent::RegisterClass(*this);
 #endif
 }
 

c2_components/src/mfx_c2_decoder_component.cpp

@@ -44,6 +44,7 @@ constexpr c2_nsecs_t TIMEOUT_NS = MFX_SECOND_NS;
 constexpr uint64_t kMinInputBufferSize = 1 * WIDTH_1K * HEIGHT_1K;
 constexpr uint64_t kDefaultConsumerUsage =
     (GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_COMPOSER);
+constexpr uint64_t kProtectedUsage = C2MemoryUsage::READ_PROTECTED;
 
 // Android S declared VP8 profile
 #if PLATFORM_SDK_VERSION <= 30 // Android 11(R)
@@ -174,7 +175,8 @@ MfxC2DecoderComponent::MfxC2DecoderComponent(const C2String name, const CreateCo
         m_bInitialized(false),
         m_uSyncedPointsCount(0),
         m_bSetHdrStatic(false),
-        m_surfaceNum(0)
+        m_surfaceNum(0),
+        m_secure(false)
 {
     MFX_DEBUG_TRACE_FUNC;
     const unsigned int SINGLE_STREAM_ID = 0u;
@@ -247,6 +249,7 @@ MfxC2DecoderComponent::MfxC2DecoderComponent(const C2String name, const CreateCo
     );
 
     switch(m_decoderType) {
+        case DECODER_H264_SECURE:
         case DECODER_H264: {
             m_uOutputDelay = /*max_dpb_size*/16 + /*for async depth*/1 + /*for msdk unref in sync part*/1;
 
@@ -302,6 +305,7 @@ MfxC2DecoderComponent::MfxC2DecoderComponent(const C2String name, const CreateCo
                 .build());
             break;
         }
+        case DECODER_H265_SECURE:
         case DECODER_H265: {
             m_uOutputDelay = /*max_dpb_size*/16 + /*for async depth*/1 + /*for msdk unref in sync part*/1;
 
@@ -934,9 +938,11 @@ void MfxC2DecoderComponent::InitFrameConstructor()
     MfxC2FrameConstructorType fc_type;
     switch (m_decoderType)
     {
+    case DECODER_H264_SECURE:
     case DECODER_H264:
         fc_type = MfxC2FC_AVC;
         break;
+    case DECODER_H265_SECURE:
     case DECODER_H265:
         fc_type = MfxC2FC_HEVC;
         break;
@@ -1096,9 +1102,11 @@ mfxStatus MfxC2DecoderComponent::ResetSettings()
 
     switch (m_decoderType)
     {
+    case DECODER_H264_SECURE:
     case DECODER_H264:
         m_mfxVideoParams.mfx.CodecId = MFX_CODEC_AVC;
         break;
+    case DECODER_H265_SECURE:
     case DECODER_H265:
         m_mfxVideoParams.mfx.CodecId = MFX_CODEC_HEVC;
         break;
@@ -1180,6 +1188,10 @@ mfxStatus MfxC2DecoderComponent::InitDecoder(std::shared_ptr<C2BlockPool> c2_all
             }
         }
 
+        if (m_secure) {
+            m_consumerUsage |= kProtectedUsage;
+        }
+
         if (MFX_ERR_NONE == mfx_res) {
             // saving parameters
             mfxVideoParam oldParams = m_mfxVideoParams;
@@ -2129,7 +2141,7 @@ void MfxC2DecoderComponent::DoWork(std::unique_ptr<C2Work>&& work)
     bool encounterResolutionChanged = false;
     do {
         std::unique_ptr<C2ReadView> read_view;
-        res = m_c2Bitstream->AppendFrame(work->input, TIMEOUT_NS, &read_view);
+        res = m_c2Bitstream->AppendFrame(work->input, TIMEOUT_NS, &read_view, codecConfig | !m_bInitialized);
         if (C2_OK != res) break;
 
         {

c2_components/src/mfx_c2_secure_decoder_component.cpp

@@ -0,0 +1,64 @@
+// Copyright (c) 2017-2024 Intel Corporation
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "mfx_c2_secure_decoder_component.h"
+
+#include "mfx_defs.h"
+#include "mfx_c2_utils.h"
+#include "mfx_debug.h"
+#include "mfx_msdk_debug.h"
+#include "mfx_c2_debug.h"
+#include "mfx_c2_components_registry.h"
+#include "mfx_defaults.h"
+#include "C2PlatformSupport.h"
+
+#undef MFX_DEBUG_MODULE_NAME
+#define MFX_DEBUG_MODULE_NAME "mfx_c2_secure_decoder_component"
+
+MfxC2SecureDecoderComponent::MfxC2SecureDecoderComponent(const C2String name, const CreateConfig& config,
+        std::shared_ptr<C2ReflectorHelper> reflector, DecoderType decoder_type) :
+        MfxC2DecoderComponent(name, config, std::move(reflector), decoder_type)
+{
+    MFX_DEBUG_TRACE_FUNC;
+    m_secure = true;
+
+    addParameter(
+        DefineParam(m_secureMode, C2_PARAMKEY_SECURE_MODE)
+        .withConstValue(new C2SecureModeTuning(C2Config::secure_mode_t::SM_READ_PROTECTED_WITH_ENCRYPTED))
+        .build());
+}
+
+MfxC2SecureDecoderComponent::~MfxC2SecureDecoderComponent()
+{
+    MFX_DEBUG_TRACE_FUNC;
+
+    MfxC2DecoderComponent::Release();
+}
+
+void MfxC2SecureDecoderComponent::RegisterClass(MfxC2ComponentsRegistry& registry)
+{
+    MFX_DEBUG_TRACE_FUNC;
+
+    registry.RegisterMfxC2Component("c2.intel.avc.decoder.secure",
+        &MfxC2Component::Factory<MfxC2SecureDecoderComponent, DecoderType>::Create<DECODER_H264_SECURE>);
+
+    registry.RegisterMfxC2Component("c2.intel.hevc.decoder.secure",
+        &MfxC2Component::Factory<MfxC2SecureDecoderComponent, DecoderType>::Create<DECODER_H265_SECURE>);
+}

c2_utils/include/mfx_c2_widevine_crypto_defs.h

@@ -0,0 +1,67 @@
+// Copyright (c) 2017-2024 Intel Corporation
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+#include <array>
+#include <mfxstructures.h>
+
+#define PROTECTED_DATA_BUFFER_MAGIC (0UL | ('E' << 24) | ('B' << 16) | ('D' << 8) | 'P')
+using IV = std::array<uint8_t, 16>;
+
+typedef unsigned int VAGenericID;
+typedef VAGenericID VAContextID;
+
+typedef enum OEMCryptoCipherMode {
+  OEMCrypto_CipherMode_CTR,
+  OEMCrypto_CipherMode_CBC,
+  OEMCrypto_CipherMode_MaxValue = OEMCrypto_CipherMode_CBC,
+} OEMCryptoCipherMode;
+
+typedef struct {
+    size_t block_offset;
+    IV current_iv;
+    size_t data_length;
+    size_t clear_bytes;
+    size_t encrypted_bytes;
+    size_t pattern_clear;
+    size_t pattern_encrypted;
+} packet_info;
+
+typedef struct {
+    uint32_t pr_magic;
+    uint32_t app_id;
+    uint32_t session_id;
+    size_t num_packet_data;
+    size_t sample_size;
+    OEMCryptoCipherMode cipher_mode;
+    uint8_t hw_key_id[16];
+    packet_info* packet_data;
+} HUCVideoBuffer;
+
+inline EncryptionScheme GetEncryptionScheme(OEMCryptoCipherMode mode) {
+    switch (mode) {
+        case OEMCrypto_CipherMode_CTR:
+            return EncryptionScheme::kCenc;
+        case OEMCrypto_CipherMode_CBC:
+            return EncryptionScheme::kCbcs;
+        default:
+            return EncryptionScheme::kUnencrypted;
+    }
+}