rmf_shim.h

Go to the documentation of this file.

/*
 * If not stated otherwise in this file or this component's license file the
 * following copyright and licenses apply:
 *
 * Copyright 2022 RDK Management
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
/**
 * @file rmf_shim.h
 * @brief shim for dispatching UVE RMF playback
 */
 
#ifndef RMF_SHIM_H_
#define RMF_SHIM_H_
 
#include "StreamAbstractionAAMP.h"
#include <string>
#include <stdint.h>
#ifdef USE_CPP_THUNDER_PLUGIN_ACCESS
#include "Module.h"
#include <core/core.h>
#include "ThunderAccess.h"
using namespace std;
 
/**
 * @struct RMFSettings
 * @brief Structure to save the ATSC settings
 */
typedef struct RMFSettings
{
        std::string preferredLanguages;
}RMFGlobalSettings;
 
/**
 * @class StreamAbstractionAAMP_RMF
 * @brief Fragment collector for RMF
 */
class StreamAbstractionAAMP_RMF : public StreamAbstractionAAMP
{
        public:
        /**
         * @fn StreamAbstractionAAMP_RMF
         * @param aamp pointer to PrivateInstanceAAMP object associated with player
         * @param seek_pos Seek position
         * @param rate playback rate
         */
        StreamAbstractionAAMP_RMF(AampLogManager *logObj, class PrivateInstanceAAMP *aamp,double seekpos, float rate);
        /**
         * @fn ~StreamAbstractionAAMP_RMF
         */
        ~StreamAbstractionAAMP_RMF();
        /**
         * @brief Copy constructor disabled
         *
         */
        StreamAbstractionAAMP_RMF(const StreamAbstractionAAMP_RMF&) = delete;
        /**
         * @brief assignment operator disabled
         *
         */
        StreamAbstractionAAMP_RMF& operator=(const StreamAbstractionAAMP_RMF&) = delete;
 
        /*Event Handlers*/
        void onPlayerStatusHandler(const JsonObject& parameters);
        void onPlayerErrorHandler(const JsonObject& parameters);
        /**
         *   @fn DumpProfiles
         */
        void DumpProfiles(void) override;
        /**
         *   @fn Start
         */
        void Start() override;
        /**
         *   @fn Stop
         */
        void Stop(bool clearChannelData) override;
        /**
         *   @fn Init
         *   @note   To be implemented by sub classes
         *   @param  tuneType to set type of object.
         *   @retval true on success
         *   @retval false on failure
         */
        AAMPStatusType Init(TuneType tuneType) override;
        /**
         * @fn GetStreamFormat
         * @param[out]  primaryOutputFormat - format of primary track
         * @param[out]  audioOutputFormat - format of audio track
         * @param[out]  auxOutputFormat - format of aux audio track
         * @param[out]  subtitleOutputFormat - format of sutbtile track
         */
        void GetStreamFormat(StreamOutputFormat &primaryOutputFormat, StreamOutputFormat &audioOutputFormat, StreamOutputFormat &auxOutputFormat, StreamOutputFormat &subtitleOutputFormat) override;
        /**
         *   @fn GetStreamPosition
         *
         *   @retval current position of stream.
         */
        double GetStreamPosition() override;
        /**
         *   @fn GetMediaTrack
         *
         *   @param[in]  type - track type
         *   @retval MediaTrack pointer.
         */
        MediaTrack* GetMediaTrack(TrackType type) override;
        /**
         *   @fn GetFirstPTS
         *
         *   @retval PTS of first sample
         */
        double GetFirstPTS() override;
        /**
         *   @fn GetStartTimeOfFirstPTS
         *
         *   @retval start time of first sample
         */
        double GetStartTimeOfFirstPTS() override;
        /**
         * @fn GetBufferedDuration
         *
         */
        double GetBufferedDuration() override;
        /**
         * @fn IsInitialCachingSupported
         */
        bool IsInitialCachingSupported() override;
        /**
         * @fn GetBWIndex
         * @param[in] bitrate Bitrate to lookup profile
         * @retval profile index
         */
        int GetBWIndex(long bitrate) override;
        /**
         * @fn GetVideoBitrates
         * @return available video bitrates
         */
        std::vector<long> GetVideoBitrates(void) override;
        /**
         * @fn GetAudioBitrates
         * @return available audio bitrates
         */
        std::vector<long> GetAudioBitrates(void) override;
        /**
         * @fn GetMaxBitrate
         * @return long MAX video bitrates
         */
        long GetMaxBitrate(void) override;
        /**
         *   @fn StopInjection
         */
        void StopInjection(void) override;
        /**
         *   @fn StartInjection
         */
        void StartInjection(void) override;
        /**
         *   @brief update the Seek position
         */
        void SeekPosUpdate(double) { };
        /**
         * @fn SetVideoRectangle
         *
         * @param[in] x,y - position coordinates of video rectangle
         * @param[in] wxh - width & height of video rectangle
         */
        void SetVideoRectangle(int x, int y, int w, int h) override;
        /**
         * @fn SetAudioTrack
         *
         * @param[in] Index of the audio track.
         */
        void SetAudioTrack(int index) override;
        /**
         * @fn SetAudioTrackByLanguage
         *
         * @param[in] lang : Audio Language to be set
         */
        void SetAudioTrackByLanguage(const char* lang) override;
        /**
         *   @fn GetAvailableAudioTracks
         *
         *   @return std::vector<AudioTrackInfo> List of available audio tracks
         */
        std::vector<AudioTrackInfo> &GetAvailableAudioTracks(bool allTrack=false) override;
        /**
         *   @fn GetAudioTrack
         *
         *   @return int - index of current audio track
         */
        int GetAudioTrack() override;
        /**
         *   @fn GetCurrentAudioTrack
         *   @return int - index of current audio track
         */
        bool GetCurrentAudioTrack(AudioTrackInfo &audioTrack) override;
        /**
         *   @fn GetAvailableTextTracks
         *   @return std::vector<TextTrackInfo> List of available text tracks
         */
        std::vector<TextTrackInfo> &GetAvailableTextTracks(bool all=false) override;
        /**
         * @fn SetPreferredAudioLanguages
         *
         */
        void SetPreferredAudioLanguages() override;
        /**
         * @fn DisableContentRestrictions
         *
         * @param[in] grace - seconds from current time, grace period, grace = -1 will allow an unlimited grace period
         * @param[in] time - seconds from current time,time till which the channel need to be kept unlocked
         * @param[in] eventChange - disable restriction handling till next program event boundary
         */
        void DisableContentRestrictions(long grace, long time, bool eventChange) override;
        /**
         * @fn EnableContentRestrictions
         *
         */
        void EnableContentRestrictions() override;
        /**
         * @fn GetAvailableVideoTracks
         * @return available video tracks
         */
        std::vector<StreamInfo*> GetAvailableVideoTracks(void) override;
        /**
         * @fn GetAvailableThumbnailTracks
         * @return available thumbnail tracks
         */
        std::vector<StreamInfo*> GetAvailableThumbnailTracks(void) override;
        /**
         * @fn SetThumbnailTrack
         *
         * @param thumbnail index value indicating the track to select
         * @return bool true on success.
         */
        bool SetThumbnailTrack(int) override;
        /**
         * @fn GetThumbnailRangeData
         * @return available thumbnail tracks
         */
        std::vector<ThumbnailData> GetThumbnailRangeData(double,double, std::string*, int*, int*, int*, int*) override;
        /**
         * @fn Is4KStream
         * @brief check if current stream have 4K content
         * @param height - resolution of 4K stream if found
         * @param bandwidth - bandwidth of 4K stream if foudd
         * @return true on success 
         */
        virtual bool Is4KStream(int &height, long &bandwidth) override {return false; };
 
        private:
        ThunderAccessAAMP thunderAccessObj;
        bool tuned;
 
        ThunderAccessAAMP thunderRDKShellObj;
        bool GetScreenResolution(int & screenWidth, int & screenHeight);
        /**
         * @fn GetAudioTracks
         * @return void
         */
        void GetAudioTracks();
        /**
         * @fn GetAudioTrackInternal
         *
         */
        int GetAudioTrackInternal();
 
        /**
         * @fn GetTextTracks
         * @return voi @return void
         */
        void GetTextTracks();
 
        protected:
        /**
         *   @fn GetStreamInfo
         *
         *   @param[in]  idx - profile index.
         *   @retval stream information corresponding to index.
         */
        StreamInfo* GetStreamInfo(int idx) override;
};
#endif //USE_CPP_THUNDER_PLUGIN_ACCESS
#endif //RMF_SHIM_H_
/**
 * @}
 */