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