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              : #include "MediaFrameWriterFactory.h"
      21              : #include "MediaFrameWriterV1.h"
      22              : #include "MediaFrameWriterV2.h"
      23              : #include "RialtoCommonLogging.h"
      24              : #include <algorithm>
      25              : #include <string>
      26              : #include <unistd.h>
      27              : 
      28              : namespace
      29              : {
      30              : constexpr int kLatestMetadataVersion{2};
      31              : const char *kMetadataEnvVariableName{"RIALTO_METADATA_VERSION"};
      32              : } // namespace
      33              : 
      34              : namespace firebolt::rialto::common
      35              : {
      36           27 : std::shared_ptr<IMediaFrameWriterFactory> IMediaFrameWriterFactory::getFactory()
      37              : try
      38              : {
      39           27 :     return std::make_shared<MediaFrameWriterFactory>();
      40              : }
      41            0 : catch (const std::exception &e)
      42              : {
      43            0 :     RIALTO_COMMON_LOG_ERROR("Failed to create the media frame writer factory, reason: %s", e.what());
      44            0 :     return nullptr;
      45              : }
      46              : 
      47           27 : MediaFrameWriterFactory::MediaFrameWriterFactory() : m_metadataVersion{kLatestMetadataVersion}
      48              : {
      49           27 :     const char *kEnvVar = getenv(kMetadataEnvVariableName);
      50           27 :     if (!kEnvVar)
      51              :     {
      52           20 :         return;
      53              :     }
      54           14 :     std::string envVarStr{kEnvVar};
      55              :     try
      56              :     {
      57            7 :         m_metadataVersion = std::stoi(envVarStr);
      58              :     }
      59            1 :     catch (const std::exception &e)
      60              :     {
      61              :     }
      62            7 :     if (m_metadataVersion > kLatestMetadataVersion)
      63              :     {
      64            1 :         m_metadataVersion = kLatestMetadataVersion;
      65              :     }
      66            7 : }
      67              : 
      68              : std::unique_ptr<IMediaFrameWriter>
      69           22 : MediaFrameWriterFactory::createFrameWriter(uint8_t *shmBuffer, const std::shared_ptr<MediaPlayerShmInfo> &shmInfo)
      70              : try
      71              : {
      72           22 :     if (1 == m_metadataVersion)
      73              :     {
      74            5 :         return std::make_unique<MediaFrameWriterV1>(shmBuffer, shmInfo);
      75              :     }
      76           17 :     return std::make_unique<MediaFrameWriterV2>(shmBuffer, shmInfo);
      77              : }
      78            0 : catch (const std::exception &e)
      79              : {
      80            0 :     RIALTO_COMMON_LOG_ERROR("Failed to create the frame writer, reason: %s", e.what());
      81            0 :     return nullptr;
      82              : }
      83              : } // namespace firebolt::rialto::common