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 "DataReaderV1.h"
      21              : #include "RialtoServerLogging.h"
      22              : #include "ShmCommon.h"
      23              : #include "TypeConverters.h"
      24              : 
      25              : namespace firebolt::rialto::server
      26              : {
      27            3 : DataReaderV1::DataReaderV1(const MediaSourceType &mediaSourceType, std::uint8_t *buffer, std::uint32_t metadataOffset,
      28            3 :                            std::uint32_t numFrames, bool isBufferFull)
      29            3 :     : m_mediaSourceType{mediaSourceType}, m_buffer{buffer}, m_metadataOffset{metadataOffset}, m_numFrames{numFrames},
      30            3 :       m_isBufferFull{isBufferFull}
      31              : {
      32            3 :     RIALTO_SERVER_LOG_DEBUG("Detected Metadata in Version 1. Media source type: %s",
      33              :                             common::convertMediaSourceType(m_mediaSourceType));
      34              :     static_assert(sizeof(DataReaderV1::MetadataV1) == common::METADATA_V1_SIZE_PER_FRAME_BYTES,
      35              :                   "Size of firebolt::rialto::server::DataReaderV1::MetadataV1 is not equal to "
      36              :                   "firebolt::rialto::common::METADATA_V1_SIZE_PER_FRAME_BYTES");
      37              : }
      38              : 
      39            2 : IMediaPipeline::MediaSegmentVector DataReaderV1::readData() const
      40              : {
      41            2 :     IMediaPipeline::MediaSegmentVector mediaSegments;
      42            2 :     auto metadatas = readMetadata();
      43            4 :     for (const auto &metadata : metadatas)
      44              :     {
      45            2 :         if (m_mediaSourceType == MediaSourceType::AUDIO)
      46              :         {
      47            1 :             mediaSegments.emplace_back(createSegment<IMediaPipeline::MediaSegmentAudio>(metadata));
      48              :         }
      49            1 :         else if (m_mediaSourceType == MediaSourceType::VIDEO)
      50              :         {
      51            1 :             mediaSegments.emplace_back(createSegment<IMediaPipeline::MediaSegmentVideo>(metadata));
      52              :         }
      53              :     }
      54            4 :     return mediaSegments;
      55            2 : }
      56              : 
      57            2 : bool DataReaderV1::isBufferFull() const
      58              : {
      59            2 :     return m_isBufferFull;
      60              : }
      61              : 
      62            2 : std::vector<DataReaderV1::MetadataV1> DataReaderV1::readMetadata() const
      63              : {
      64            2 :     std::vector<DataReaderV1::MetadataV1> result;
      65            2 :     std::uint8_t *regionMetadataOffset = m_buffer + m_metadataOffset;
      66            4 :     for (std::uint32_t frame = 0; frame < m_numFrames; ++frame)
      67              :     {
      68            2 :         std::uint8_t *frameMetadataOffset = regionMetadataOffset + (frame * common::METADATA_V1_SIZE_PER_FRAME_BYTES);
      69            2 :         DataReaderV1::MetadataV1 *metadataPtr = reinterpret_cast<DataReaderV1::MetadataV1 *>(frameMetadataOffset);
      70            2 :         result.emplace_back(*metadataPtr);
      71              :     }
      72            2 :     return result;
      73              : }
      74              : } // namespace firebolt::rialto::server