aampgstplayer.h

/*
 * If not stated otherwise in this file or this component's license file the
 * following copyright and licenses apply:
 *
 * Copyright 2018 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 aampgstplayer.h
 * @brief Gstreamer based player for AAMP
 */

#ifndef AAMPGSTPLAYER_H
#define AAMPGSTPLAYER_H

#include <stddef.h>
#include <functional>
#include <gst/gst.h>
#include "priv_aamp.h"
#include <pthread.h>

/**
 * @struct AAMPGstPlayerPriv
 * @brief forward declaration of AAMPGstPlayerPriv
 */
struct AAMPGstPlayerPriv;

/**
 * @struct TaskControlData
 * @brief data for scheduling and handling asynchronous tasks
 */
struct TaskControlData
{
	guint       taskID;
	bool        taskIsPending;
	std::string taskName;
	TaskControlData(const char* taskIdent) : taskID(0), taskIsPending(false), taskName(taskIdent ? taskIdent : "undefined") {};
};

/**
 * @brief Function pointer for the idle task
 * @param[in] arg - Arguments
 * @return Idle task status
 */
typedef int(*BackgroundTask)(void* arg);


/**
 * @class AAMPGstPlayer
 * @brief Class declaration of Gstreamer based player
 */
class AAMPGstPlayer : public StreamSink
{
private:
	/**
         * @fn SendHelper
         * @param[in] mediaType stream type
         * @param[in] ptr buffer pointer
         * @param[in] len length of buffer
         * @param[in] fpts PTS of buffer (in sec)
         * @param[in] fdts DTS of buffer (in sec)
         * @param[in] duration duration of buffer (in sec)
         * @param[in] copy to map or transfer the buffer
         * @param[in] initFragment flag for buffer type (init, data)
         */
	bool SendHelper(MediaType mediaType, const void *ptr, size_t len, double fpts, double fdts, double duration, bool copy, bool initFragment = 0, bool discontinuity = false);

	/**
	 * @fn SendGstEvents
	 * @param[in] mediaType stream type
	 * @param[in] pts PTS of next buffer
	 * @param[in] ptr buffer pointer
	 * @param[in] len length of buffer
	 */
	void SendGstEvents(MediaType mediaType, GstClockTime pts, const void *ptr, size_t len);

	/**
	 * @fn RecalculatePTS
	 * @param[in] mediaType stream type
	 * @param[in] ptr buffer pointer
	 * @param[in] len length of buffer
	 */
	double RecalculatePTS(MediaType mediaType, const void *ptr, size_t len);

	/**
         * @fn SendNewSegmentEvent
         * @param[in] mediaType stream type
         * @param[in] startPts Start Position of first buffer
         * @param[in] stopPts Stop position of last buffer
         */
	void SendNewSegmentEvent(MediaType mediaType, GstClockTime startPts ,GstClockTime stopPts = 0);

public:
	class PrivateInstanceAAMP *aamp;
	/**
         * @fn Configure
         * @param[in] format video format
         * @param[in] audioFormat audio format
         * @param[in] auxFormat aux audio format
         * @param[in] subFormat subtitle format
         * @param[in] bESChangeStatus flag to indicate if the audio type changed in mid stream
         * @param[in] forwardAudioToAux if audio buffers to be forwarded to aux pipeline
         * @param[in] setReadyAfterPipelineCreation True/False for pipeline is created
         */
	void Configure(StreamOutputFormat format, StreamOutputFormat audioFormat, StreamOutputFormat auxFormat, StreamOutputFormat subFormat, bool bESChangeStatus, bool forwardAudioToAux, bool setReadyAfterPipelineCreation=false);
	/**
         * @fn SendCopy
         * @param[in] mediaType stream type
         * @param[in] ptr buffer pointer
         * @param[in] len length of buffer
         * @param[in] fpts PTS of buffer (in sec)
         * @param[in] fdts DTS of buffer (in sec)
         * @param[in] duration duration of buffer (in sec)
         */
	bool SendCopy(MediaType mediaType, const void *ptr, size_t len, double fpts, double fdts, double duration);
	/**
         * @fn SendTransfer
         * @param[in] mediaType stream type
         * @param[in] buffer buffer as GrowableBuffer pointer
         * @param[in] fpts PTS of buffer (in sec)
         * @param[in] fdts DTS of buffer (in sec)
         * @param[in] duration duration of buffer (in sec)
         * @param[in] initFragment flag for buffer type (init, data)
         */
	bool SendTransfer(MediaType mediaType, void *ptr, size_t len, double fpts, double fdts, double duration, bool initFragment = false, bool discontinuity = false);
	/**
         * @fn EndOfStreamReached
         * @param[in] type stream type
         */
	void EndOfStreamReached(MediaType type);
	/**
         * @fn Stream
         */
	void Stream(void);

	/**
         * @fn Stop
         * @param[in] keepLastFrame denotes if last video frame should be kept
         */
	void Stop(bool keepLastFrame);
	/**
         * @fn Flush
         * @param[in] position playback seek position
         * @param[in] rate playback rate
         * @param[in] shouldTearDown flag indicates if pipeline should be destroyed if in invalid state
         */
	void Flush(double position, int rate, bool shouldTearDown);
	/**
         * @fn Pause
         * @param[in] pause flag to pause/play the pipeline
         * @param[in] forceStopGstreamerPreBuffering - true for disabling bufferinprogress
         * @retval true if content successfully paused
         */
	bool Pause(bool pause, bool forceStopGstreamerPreBuffering);
	/**
         * @fn GetPositionMilliseconds
         * @retval playback position in MS
         */
	long GetPositionMilliseconds(void);
        /**
         * @fn GetDurationMilliseconds 
         * @retval playback duration in MS
         */
	long GetDurationMilliseconds(void);
	/**
         * @fn getCCDecoderHandle
         * @retval the decoder handle
         */
	unsigned long getCCDecoderHandle(void);
	/**
         * @fn GetVideoPTS
         * @retval Video PTS value
         */
	virtual long long GetVideoPTS(void);
	/**
         * @fn SetVideoRectangle
         * @param[in] x x co-ordinate of display rectangle
         * @param[in] y y co-ordinate of display rectangle
         * @param[in] w width of display rectangle
         * @param[in] h height of display rectangle
         */
	void SetVideoRectangle(int x, int y, int w, int h);
	/**
         * @fn Discontinuity
         * @param mediaType Media stream type
         * @retval true if discontinuity processed
         */
	bool Discontinuity( MediaType mediaType);
	/**
         * @fn SetVideoZoom
         * @param[in] zoom zoom setting to be set
         */
	void SetVideoZoom(VideoZoomMode zoom);
	/**
         * @fn SetVideoMute
         * @param[in] muted true to mute video otherwise false
         */
	void SetVideoMute(bool muted);
	/**
         * @fn SetAudioVolume
         * @param[in] volume audio volume value (0-100)
         */
	void SetAudioVolume(int volume);
	/**
         * @fn SetSubtitleMute
         * @param[in] muted true to mute subtitle otherwise false
         */
	void SetSubtitleMute(bool mute);
	/**
         * @fn SetSubtitlePtsOffset
         * @param[in] pts_offset pts offset for subs
         */
	void SetSubtitlePtsOffset(std::uint64_t pts_offset);
	/**
         * @fn setVolumeOrMuteUnMute
         * @note set privateContext->audioVolume before calling this function
         */
	void setVolumeOrMuteUnMute(void);
	/**
         * @fn IsCacheEmpty
         * @param[in] mediaType stream type
         * @retval true if cache empty
         */
	bool IsCacheEmpty(MediaType mediaType);
	/**
         * @fn ResetEOSSignalledFlag
         */
	void ResetEOSSignalledFlag();
	/**
         * @fn CheckForPTSChangeWithTimeout
         *
         * @param[in] timeout - to check if PTS hasn't changed within a time duration
         */
	bool CheckForPTSChangeWithTimeout(long timeout);
	/**
         * @fn NotifyFragmentCachingComplete
         */
	void NotifyFragmentCachingComplete();
	/**
         * @fn NotifyFragmentCachingOngoing
         */
	void NotifyFragmentCachingOngoing();
	/**
         * @fn GetVideoSize
         * @param[out] w width video width
         * @param[out] h height video height
         */
	void GetVideoSize(int &w, int &h);
	/**
         * @fn QueueProtectionEvent
         * @param[in] protSystemId keysystem to be used
         * @param[in] ptr initData DRM initialization data
         * @param[in] len initDataSize DRM initialization data size
         * @param[in] type Media type
         */
	void QueueProtectionEvent(const char *protSystemId, const void *ptr, size_t len, MediaType type);
	/**
         * @fn ClearProtectionEvent
         */
	void ClearProtectionEvent();
	/**
         * @fn IdleTaskAdd
         * @param[in] taskDetails task control data (e.g. id, pending flag and task name)
         * @param[in] funcPtr function pointer to add to the asynchronous queue task
         * @return true - if task was added
         */
	bool IdleTaskAdd(TaskControlData& taskDetails, BackgroundTask funcPtr);
	/**
         * @fn IdleTaskRemove
         * @param[in] taskDetails task control data (e.g. id, pending flag and task name)
         * @return true - if task was removed
         */
	bool IdleTaskRemove(TaskControlData& taskDetails);
	/**
         * @fn IdleTaskClearFlags
         * @param[in] taskDetails task control data (e.g. id, pending flag and task name)
         */
	void IdleTaskClearFlags(TaskControlData& taskDetails);
	/**
         * @fn TimerAdd
         * @param[in] funcPtr function to execute on timer expiry
         * @param[in] repeatTimeout timeout between calls in ms
         * @param[in] user_data data to pass to the timer function
         * @param[in] timerName name of the timer being added
         * @param[out] taskId id of the timer to be returned
         */
	void TimerAdd(GSourceFunc funcPtr, int repeatTimeout, guint& taskId, gpointer user_data, const char* timerName = nullptr);
	/**
         * @fn TimerRemove
         * @param[in] taskId id of the timer to be removed
         * @param[in] timerName name of the timer being removed (for debug) (opt)
         */
	void TimerRemove(guint& taskId, const char* timerName = nullptr);
	/**
         * @fn TimerIsRunning
         * @param[in] taskId id of the timer to be removed
         * @return true - timer is currently running
         */
	bool TimerIsRunning(guint& taskId);
	/**
         * @fn StopBuffering
         *
         * @param[in] forceStop - true to force end buffering
         */
	void StopBuffering(bool forceStop);
	/**
	 * @fn SetPlayBackRate
	 * @param[in] rate playback rate
	 * @return true if playrate adjusted
	 */
	bool SetPlayBackRate ( double rate );

	bool PipelineSetToReady; /**< To indicate the pipeline is set to ready forcefully */
	bool trickTeardown;		/**< To indicate that the tear down is initiated in trick play */
	struct AAMPGstPlayerPriv *privateContext;
	/**
         * @fn AAMPGstPlayer
         *  
         */
	AAMPGstPlayer(AampLogManager *logObj, PrivateInstanceAAMP *aamp
#ifdef RENDER_FRAMES_IN_APP_CONTEXT
	, std::function< void(uint8_t *, int, int, int) > exportFrames = nullptr
#endif
	);
	AAMPGstPlayer(const AAMPGstPlayer&) = delete;
	AAMPGstPlayer& operator=(const AAMPGstPlayer&) = delete;
	/**
     	 * @fn ~AAMPGstPlayer
     	 */
	~AAMPGstPlayer();
	/**
     	 * @fn InitializeAAMPGstreamerPlugins
     	 */
	static void InitializeAAMPGstreamerPlugins(AampLogManager *logObj=NULL);
	/**
	 * @fn NotifyEOS
     	 */
	void NotifyEOS();
	/**
     	 * @fn NotifyFirstFrame
     	 * @param[in] type media type of the frame which is decoded, either audio or video.
     	 */
	void NotifyFirstFrame(MediaType type);
	/**
     	 * @fn DumpDiagnostics
    	 *
     	 */
	void DumpDiagnostics();
	/**
     	 *   @fn SignalTrickModeDiscontinuity
     	 *   @return void
     	 */
	void SignalTrickModeDiscontinuity();
#ifdef RENDER_FRAMES_IN_APP_CONTEXT
	std::function< void(uint8_t *, int, int, int) > cbExportYUVFrame;
	/**
     	 * @fn AAMPGstPlayer_OnVideoSample
     	 * @param[in] object - pointer to appsink instance triggering "new-sample" signal
     	 * @param[in] _this  - pointer to AAMPGstPlayer instance
     	 * @retval GST_FLOW_OK
     	 */
	static GstFlowReturn AAMPGstPlayer_OnVideoSample(GstElement* object, AAMPGstPlayer * _this);
#endif
    	/**
     	 * @fn SeekStreamSink
     	 * @param position playback seek position
	 * @param rate play rate  
     	 */
	void SeekStreamSink(double position, double rate);
	
	/**
     	 * @fn static IsCodecSupported
    	 * @param[in] codecName - name of the codec value
     	 */
	static bool IsCodecSupported(const std::string &codecName);
	
	/**
     	 *   @fn GetVideoRectangle
    	 *
     	 */
	std::string GetVideoRectangle();
	
	/**
         * @fn to check MS2V12Supported or not
         *
         */

        static bool IsMS2V12Supported();
	/**
        *   @fn SignalConnect
	    *   @note wraps g_signal_connect, adds functionality required by DisconnectSignals()
	 */
	void SignalConnect(gpointer instance, const gchar *detailed_signal, GCallback c_handler, gpointer data);

	/**
		* @brief Set the text style of the subtitle to the options passed
		* @fn SetTextStyle()
		* @param[in] options - reference to the Json string that contains the information
		* @return - true indicating successful operation in passing options to the parser
	 */
	bool SetTextStyle(const std::string &options) override;

private:
	/**
     	 * @fn PauseAndFlush 
     	 * @param playAfterFlush denotes if it should be set to playing at the end
     	 */
	void PauseAndFlush(bool playAfterFlush);
	/**
     	 * @fn TearDownStream
     	 * @param[in] mediaType stream type
     	 */
	void TearDownStream(MediaType mediaType);
	/**
     	 * @fn CreatePipeline
     	 */
	bool CreatePipeline();
	/**
     	 * @fn DestroyPipeline
     	 */
	void DestroyPipeline();
	static bool initialized;
    	/**
     	 * @fn Flush
     	 */ 
	void Flush(void);
	/**
     	 * @brief Flush last saved ID3 metadata
     	 * @return void
     	 */
	void FlushLastId3Data();
    	/**
     	 * @fn WaitForSourceSetup
     	 *
     	 * @param[in] mediaType - source element for media type
     	 * @return bool - true if source setup completed within timeout
     	 */
	bool WaitForSourceSetup(MediaType mediaType);
	/**
     	 * @fn ForwardBuffersToAuxPipeline
    	 *
     	 * @param[in] buffer - input buffer to be forwarded
     	 */
	void ForwardBuffersToAuxPipeline(GstBuffer *buffer);
	/**
     	 * @fn ForwardAudioBuffersToAux
     	 *
     	 * @return bool - true if audio to be forwarded
     	 */
	bool ForwardAudioBuffersToAux();

	/**
         *   @fn DisconnectSignals
	     *   @brief runs g_signal_handler_disconnect() for signals connected using SignalConnect() since
	     *  this function was last called unless
	     *  these were subsequently removed using RemoveSignalsFromDisconnectList()
	     */
	void DisconnectSignals();

	/**
	     *   @fn RemoveSignalsFromDisconnectList
	     *   @brief Prevents signals associated with the supplied element from being disconnected by DisconnectSignals
	     */
	void RemoveSignalsFromDisconnectList(const gpointer pElementOrBin);

	pthread_mutex_t mBufferingLock;
	pthread_mutex_t mProtectionLock;
	AampLogManager *mLogObj;
};

#endif // AAMPGSTPLAYER_H