LCOV - code coverage report
Current view: top level - media/server/main/include - MediaKeysServerInternal.h (source / functions) Coverage Total Hit
Test: coverage.info Lines: 100.0 % 2 2
Test Date: 2025-06-05 13:57:59 Functions: 100.0 % 2 2

            Line data    Source code
       1              : /*
       2              :  * If not stated otherwise in this file or this component's LICENSE file the
       3              :  * following copyright and licenses apply:
       4              :  *
       5              :  * Copyright 2022 Sky UK
       6              :  *
       7              :  * Licensed under the Apache License, Version 2.0 (the "License");
       8              :  * you may not use this file except in compliance with the License.
       9              :  * You may obtain a copy of the License at
      10              :  *
      11              :  * http://www.apache.org/licenses/LICENSE-2.0
      12              :  *
      13              :  * Unless required by applicable law or agreed to in writing, software
      14              :  * distributed under the License is distributed on an "AS IS" BASIS,
      15              :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      16              :  * See the License for the specific language governing permissions and
      17              :  * limitations under the License.
      18              :  */
      19              : 
      20              : #ifndef FIREBOLT_RIALTO_SERVER_MEDIA_KEYS_SERVER_INTERNAL_H_
      21              : #define FIREBOLT_RIALTO_SERVER_MEDIA_KEYS_SERVER_INTERNAL_H_
      22              : 
      23              : #include "IMainThread.h"
      24              : #include "IMediaKeySession.h"
      25              : #include "IMediaKeysServerInternal.h"
      26              : #include "IOcdmSystem.h"
      27              : #include <map>
      28              : #include <memory>
      29              : #include <string>
      30              : #include <vector>
      31              : 
      32              : namespace firebolt::rialto::server
      33              : {
      34              : /**
      35              :  * @brief IMediaKeys factory class definition.
      36              :  */
      37              : class MediaKeysServerInternalFactory : public IMediaKeysServerInternalFactory
      38              : {
      39              : public:
      40            2 :     MediaKeysServerInternalFactory() = default;
      41            2 :     ~MediaKeysServerInternalFactory() override = default;
      42              : 
      43              :     std::unique_ptr<IMediaKeys> createMediaKeys(const std::string &keySystem) const override;
      44              :     std::unique_ptr<IMediaKeysServerInternal> createMediaKeysServerInternal(const std::string &keySystem) const override;
      45              : };
      46              : 
      47              : }; // namespace firebolt::rialto::server
      48              : 
      49              : namespace firebolt::rialto::server
      50              : {
      51              : /**
      52              :  * @brief The definition of the MediaKeysServerInternal.
      53              :  */
      54              : class MediaKeysServerInternal : public IMediaKeysServerInternal
      55              : {
      56              : public:
      57              :     struct MediaKeySessionUsage
      58              :     {
      59              :         std::unique_ptr<IMediaKeySession> mediaKeySession;
      60              :         uint32_t bufCounter = 0;
      61              :         bool shouldBeClosed = false;
      62              :         bool shouldBeReleased = false;
      63              :     };
      64              :     /**
      65              :      * @brief The constructor.
      66              :      *
      67              :      * @param[in] keySystem                 : The key system for which to create a Media Keys instance.
      68              :      * @param[in] mainThreadFactory         : The main thread factory.
      69              :      * @param[in] ocdmSystemFactory         : The ocdm system factory.
      70              :      * @param[in] mediaKeySessionFactory    : The media key session factory.
      71              :      *
      72              :      */
      73              :     MediaKeysServerInternal(const std::string &keySystem, const std::shared_ptr<IMainThreadFactory> &mainThreadFactory,
      74              :                             std::shared_ptr<firebolt::rialto::wrappers::IOcdmSystemFactory> ocdmSystemFactory,
      75              :                             std::shared_ptr<IMediaKeySessionFactory> mediaKeySessionFactory);
      76              : 
      77              :     /**
      78              :      * @brief Virtual destructor.
      79              :      */
      80              :     virtual ~MediaKeysServerInternal();
      81              : 
      82              :     MediaKeyErrorStatus selectKeyId(int32_t keySessionId, const std::vector<uint8_t> &keyId) override;
      83              : 
      84              :     bool containsKey(int32_t keySessionId, const std::vector<uint8_t> &keyId) override;
      85              : 
      86              :     MediaKeyErrorStatus createKeySession(KeySessionType sessionType, std::weak_ptr<IMediaKeysClient> client, bool isLDL,
      87              :                                          int32_t &keySessionId) override;
      88              : 
      89              :     MediaKeyErrorStatus generateRequest(int32_t keySessionId, InitDataType initDataType,
      90              :                                         const std::vector<uint8_t> &initData) override;
      91              : 
      92              :     MediaKeyErrorStatus loadSession(int32_t keySessionId) override;
      93              : 
      94              :     MediaKeyErrorStatus updateSession(int32_t keySessionId, const std::vector<uint8_t> &responseData) override;
      95              : 
      96              :     MediaKeyErrorStatus setDrmHeader(int32_t keySessionId, const std::vector<uint8_t> &requestData) override;
      97              : 
      98              :     MediaKeyErrorStatus closeKeySession(int32_t keySessionId) override;
      99              : 
     100              :     MediaKeyErrorStatus removeKeySession(int32_t keySessionId) override;
     101              : 
     102              :     MediaKeyErrorStatus deleteDrmStore() override;
     103              : 
     104              :     MediaKeyErrorStatus deleteKeyStore() override;
     105              : 
     106              :     MediaKeyErrorStatus getDrmStoreHash(std::vector<unsigned char> &drmStoreHash) override;
     107              : 
     108              :     MediaKeyErrorStatus getKeyStoreHash(std::vector<unsigned char> &keyStoreHash) override;
     109              : 
     110              :     MediaKeyErrorStatus getLdlSessionsLimit(uint32_t &ldlLimit) override;
     111              : 
     112              :     MediaKeyErrorStatus getLastDrmError(int32_t keySessionId, uint32_t &errorCode) override;
     113              : 
     114              :     MediaKeyErrorStatus getDrmTime(uint64_t &drmTime) override;
     115              : 
     116              :     MediaKeyErrorStatus getCdmKeySessionId(int32_t keySessionId, std::string &cdmKeySessionId) override;
     117              : 
     118              :     MediaKeyErrorStatus releaseKeySession(int32_t keySessionId) override;
     119              : 
     120              :     MediaKeyErrorStatus decrypt(int32_t keySessionId, GstBuffer *encrypted, GstCaps *caps) override;
     121              : 
     122              :     MediaKeyErrorStatus getMetricSystemData(std::vector<uint8_t> &buffer) override;
     123              : 
     124              :     bool hasSession(int32_t keySessionId) const override;
     125              : 
     126              :     bool isNetflixPlayreadyKeySystem(int32_t keySessionId) const override;
     127              : 
     128              :     void incrementSessionIdUsageCounter(int32_t keySessionId) override;
     129              :     void decrementSessionIdUsageCounter(int32_t keySessionId) override;
     130              :     void ping(std::unique_ptr<IHeartbeatHandler> &&heartbeatHandler) override;
     131              : 
     132              : private:
     133              :     /**
     134              :      * @brief The mainThread object.
     135              :      */
     136              :     std::shared_ptr<IMainThread> m_mainThread;
     137              : 
     138              :     /**
     139              :      * @brief The factory for creating MediaKeySessions.
     140              :      */
     141              :     std::shared_ptr<IMediaKeySessionFactory> m_mediaKeySessionFactory;
     142              : 
     143              :     /**
     144              :      * @brief The IOcdmSystem instance.
     145              :      */
     146              :     std::shared_ptr<firebolt::rialto::wrappers::IOcdmSystem> m_ocdmSystem;
     147              : 
     148              :     /**
     149              :      * @brief Map containing created sessions.
     150              :      */
     151              :     std::map<int32_t, MediaKeySessionUsage> m_mediaKeySessions;
     152              : 
     153              :     /**
     154              :      * @brief KeySystem type of the MediaKeysServerInternal.
     155              :      */
     156              :     const std::string m_keySystem;
     157              : 
     158              :     /**
     159              :      * @brief This objects id registered on the main thread
     160              :      */
     161              :     uint32_t m_mainThreadClientId;
     162              : 
     163              :     /**
     164              :      * @brief Creates a session internally, only to be called on the main thread.
     165              :      *
     166              :      * @param[in]  sessionType : The session type.
     167              :      * @param[in]  client      : Client object for callbacks
     168              :      * @param[in]  isLDL       : Is this an LDL
     169              :      * @param[out] keySessionId: The key session id
     170              :      *
     171              :      * @retval an error status.
     172              :      */
     173              :     MediaKeyErrorStatus createKeySessionInternal(KeySessionType sessionType, std::weak_ptr<IMediaKeysClient> client,
     174              :                                                  bool isLDL, int32_t &keySessionId);
     175              : 
     176              :     /**
     177              :      * @brief Generate internally, only to be called on the main thread.
     178              :      *
     179              :      * @param[in]  keySessionId : The key session id for the session.
     180              :      * @param[in]  initDataType : The init data type.
     181              :      * @param[in]  initData     : The init data.
     182              :      *
     183              :      * @retval an error status.
     184              :      */
     185              :     MediaKeyErrorStatus generateRequestInternal(int32_t keySessionId, InitDataType initDataType,
     186              :                                                 const std::vector<uint8_t> &initData);
     187              : 
     188              :     /**
     189              :      * @brief Load internally, only to be called on the main thread.
     190              :      *
     191              :      * @param[in] keySessionId : The key session id for the session.
     192              :      *
     193              :      * @retval an error status.
     194              :      */
     195              :     MediaKeyErrorStatus loadSessionInternal(int32_t keySessionId);
     196              : 
     197              :     /**
     198              :      * @brief Update internally, only to be called on the main thread.
     199              :      *
     200              :      * @param[in] keySessionId : The key session id for the session.
     201              :      * @param[in] responseData : The license response data.
     202              :      *
     203              :      * @retval an error status.
     204              :      */
     205              :     MediaKeyErrorStatus updateSessionInternal(int32_t keySessionId, const std::vector<uint8_t> &responseData);
     206              : 
     207              :     /**
     208              :      * @brief Close a key session internally, only to be called on the main thread.
     209              :      *
     210              :      * @param[in] keySessionId : The key session id.
     211              :      *
     212              :      * @retval an error status.
     213              :      */
     214              :     MediaKeyErrorStatus closeKeySessionInternal(int32_t keySessionId);
     215              : 
     216              :     /**
     217              :      * @brief Removes a key session internally, only to be called on the main thread.
     218              :      *
     219              :      * @param[in] keySessionId : The key session id.
     220              :      *
     221              :      * @retval an error status.
     222              :      */
     223              :     MediaKeyErrorStatus removeKeySessionInternal(int32_t keySessionId);
     224              : 
     225              :     /**
     226              :      * @brief Get the key session id internally, only to be called on the main thread.
     227              :      *
     228              :      * @param[in]   keySessionId    : The key session id for the session.
     229              :      * @param[out]  cdmKeySessionId : The internal CDM key session ID
     230              :      *
     231              :      * @retval an error status.
     232              :      */
     233              :     MediaKeyErrorStatus getCdmKeySessionIdInternal(int32_t keySessionId, std::string &cdmKeySessionId);
     234              : 
     235              :     /**
     236              :      * @brief Decrypt internally, only to be called on the main thread.
     237              :      *
     238              :      * @param[in] keySessionId    : The session id for the session.
     239              :      * @param[in] encrypted       : Gstreamer buffer containing encrypted data and related meta data. If applicable,
     240              :      *                              decrypted data will be stored here after this call returns.
     241              :      * @param[in] caps            : The gst caps of buffer.
     242              :      *
     243              :      * @retval an error status.
     244              :      */
     245              :     MediaKeyErrorStatus decryptInternal(int32_t keySessionId, GstBuffer *encrypted, GstCaps *caps);
     246              : 
     247              :     /**
     248              :      * @brief Selects the specified keyId for the key session internally, only to be called on the main thread.
     249              :      *
     250              :      * @param[in] keySessionId : The key session id for the session.
     251              :      * @param[in] keyId        : The key id to select.
     252              :      *
     253              :      * @retval an error status.
     254              :      */
     255              :     MediaKeyErrorStatus selectKeyIdInternal(int32_t keySessionId, const std::vector<uint8_t> &keyId);
     256              : 
     257              :     /**
     258              :      * @brief Returns true if the Key Session object contains the specified key internally,
     259              :      *        only to be called on the main thread.
     260              :      *
     261              :      * @param[in] keySessionId : The key session id for the session.
     262              :      * @param[in] keyId        : The key id.
     263              :      *
     264              :      * @retval true if it contains the key.
     265              :      */
     266              :     bool containsKeyInternal(int32_t keySessionId, const std::vector<uint8_t> &keyId);
     267              : 
     268              :     /**
     269              :      * @brief Set DRM Header for a key session internally, only to be called on the main thread.
     270              :      *
     271              :      * @param[in] keySessionId : The session id for the session.
     272              :      * @param[in] requestData  : The request data.
     273              :      *
     274              :      * @retval an error status.
     275              :      */
     276              :     MediaKeyErrorStatus setDrmHeaderInternal(int32_t keySessionId, const std::vector<uint8_t> &requestData);
     277              : 
     278              :     /**
     279              :      * @brief Get the last cdm specific DRM error code internally, only to be called on the main thread.
     280              :      *
     281              :      * @param[in] keySessionId : The key session id.
     282              :      * @param[out] errorCode : the error code.
     283              :      *
     284              :      * @retval the return status value.
     285              :      */
     286              :     MediaKeyErrorStatus getLastDrmErrorInternal(int32_t keySessionId, uint32_t &errorCode);
     287              : 
     288              :     /**
     289              :      * @brief Checks, if key system of media key session is Netflix Playready internally, only to be called on the main thread.
     290              :      *
     291              :      * @param[in] keySessionId    : The session id for the session.
     292              :      *
     293              :      * @retval true if key system is Playready
     294              :      */
     295              :     bool isNetflixPlayreadyKeySystemInternal(int32_t keySessionId) const;
     296              : 
     297              :     /**
     298              :      * @brief Releases a key session internally, only to be called on the main thread.
     299              :      *
     300              :      * @param[in] keySessionId : The key session id.
     301              :      *
     302              :      * @retval an error status.
     303              :      */
     304              :     MediaKeyErrorStatus releaseKeySessionInternal(int32_t keySessionId);
     305              : 
     306              :     void incrementSessionIdUsageCounterInternal(int32_t keySessionId);
     307              :     void decrementSessionIdUsageCounterInternal(int32_t keySessionId);
     308              : };
     309              : 
     310              : }; // namespace firebolt::rialto::server
     311              : 
     312              : #endif // FIREBOLT_RIALTO_SERVER_MEDIA_KEYS_SERVER_INTERNAL_H_
        

Generated by: LCOV version 2.0-1