priv_aamp.cpp

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 2020 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 priv_aamp.cpp
 * @brief Advanced Adaptive Media Player (AAMP) PrivateInstanceAAMP impl
 */
#include "isobmffprocessor.h"
#include "priv_aamp.h"
#include "AampJsonObject.h"
#include "isobmffbuffer.h"
#include "AampFnLogger.h"
#include "AampConstants.h"
#include "AampCacheHandler.h"
#include "AampUtils.h"
#include "iso639map.h"
#include "fragmentcollector_mpd.h"
#include "admanager_mpd.h"
#include "fragmentcollector_hls.h"
#include "fragmentcollector_progressive.h"
#include "MediaStreamContext.h"
#include "hdmiin_shim.h"
#include "compositein_shim.h"
#include "ota_shim.h"
#ifdef USE_CPP_THUNDER_PLUGIN_ACCESS
#include "rmf_shim.h"
#endif
#include "_base64.h"
#include "base16.h"
#include "aampgstplayer.h"
#include "AampDRMSessionManager.h"
#include "SubtecFactory.hpp"
 
#ifdef AAMP_CC_ENABLED
#include "AampCCManager.h"
#endif
#ifdef USE_OPENCDM // AampOutputProtection is compiled when this  flag is enabled
#include "aampoutputprotection.h"
#endif
 
#include "AampCurlStore.h"
 
#ifdef IARM_MGR
#include "host.hpp"
#include "manager.hpp"
#include "libIBus.h"
#include "libIBusDaemon.h"
#include <hostIf_tr69ReqHandler.h>
#include <sstream>
#endif
#include <sys/time.h>
#include <cmath>
#include <regex>
#include <fstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <uuid/uuid.h>
#include <string.h>
 
#define LOCAL_HOST_IP       "127.0.0.1"
#define AAMP_MAX_TIME_BW_UNDERFLOWS_TO_TRIGGER_RETUNE_MS (20*1000LL)
#define AAMP_MAX_TIME_LL_BW_UNDERFLOWS_TO_TRIGGER_RETUNE_MS (AAMP_MAX_TIME_BW_UNDERFLOWS_TO_TRIGGER_RETUNE_MS/10)
 
//Description size
#define MAX_DESCRIPTION_SIZE 128
 
//Stringification of Macro :  use two levels of macros
#define MACRO_TO_STRING(s) X_STR(s)
#define X_STR(s) #s
 
// Uncomment to test GetMediaFormatType without locator inspection
#define TRUST_LOCATOR_EXTENSION_IF_PRESENT
 
#define VALIDATE_INT(param_name, param_value, default_value)        \
    if ((param_value <= 0) || (param_value > INT_MAX))  { \
        AAMPLOG_WARN("Parameter '%s' not within INTEGER limit. Using default value instead.", param_name); \
        param_value = default_value; \
    }
 
#define VALIDATE_LONG(param_name, param_value, default_value)        \
    if ((param_value <= 0) || (param_value > LONG_MAX))  { \
        AAMPLOG_WARN("Parameter '%s' not within LONG INTEGER limit. Using default value instead.", param_name); \
        param_value = default_value; \
    }
 
#define VALIDATE_DOUBLE(param_name, param_value, default_value)        \
    if ((param_value <= 0) || (param_value > DBL_MAX))  { \
        AAMPLOG_WARN("Parameter '%s' not within DOUBLE limit. Using default value instead.", param_name); \
        param_value = default_value; \
    }
 
#define CURL_EASY_SETOPT(curl, CURLoption, option)\
    if (curl_easy_setopt(curl, CURLoption, option) != 0) {\
          logprintf("Failed at curl_easy_setopt ");\
    }  //CID:132698,135078 - checked return
 
#define FOG_REASON_STRING                       "Fog-Reason:"
#define CURLHEADER_X_REASON                     "X-Reason:"
#define BITRATE_HEADER_STRING           "X-Bitrate:"
#define CONTENTLENGTH_STRING            "Content-Length:"
#define SET_COOKIE_HEADER_STRING        "Set-Cookie:"
#define LOCATION_HEADER_STRING          "Location:"
#define CONTENT_ENCODING_STRING         "Content-Encoding:"
#define FOG_RECORDING_ID_STRING         "Fog-Recording-Id:"
#define CAPPED_PROFILE_STRING           "Profile-Capped:"
#define TRANSFER_ENCODING_STRING                "Transfer-Encoding:"
 
#define MAX_DOWNLOAD_DELAY_LIMIT_MS 30000
 
/**
 * New state for treating a VOD asset as a "virtual linear" stream
 */
// Note that below state/impl currently assumes single profile, and so until fixed should be tested with "abr" in aamp.cfg to disable ABR
static long long simulation_start; // time at which main manifest was downloaded.
// Simulation_start is used to calculate elapsed time, used to advance virtual live window
static char *full_playlist_video_ptr = NULL; // Cache of initial full vod video playlist
static size_t full_playlist_video_len = 0; // Size (bytes) of initial full vod video playlist
static char *full_playlist_audio_ptr = NULL; // Cache of initial full vod audio playlist
static size_t full_playlist_audio_len = 0; // Size (bytes) of initial full vod audio playlist
 
/**
 * @struct gActivePrivAAMP_t
 * @brief Used for storing active PrivateInstanceAAMPs
 */
struct gActivePrivAAMP_t
{
        PrivateInstanceAAMP* pAAMP;
        bool reTune;
        int numPtsErrors;
};
 
static std::list<gActivePrivAAMP_t> gActivePrivAAMPs = std::list<gActivePrivAAMP_t>();
 
static pthread_mutex_t gMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t gCond = PTHREAD_COND_INITIALIZER;
 
static int PLAYERID_CNTR = 0;
 
static const char* strAAMPPipeName = "/tmp/ipc_aamp";
 
static bool activeInterfaceWifi = false;
 
static char previousInterface[20] = {'\0'};
 
static unsigned int ui32CurlTrace = 0;
/**
 * @struct CurlCbContextSyncTime 
 * @brief context during curl callbacks
 */
struct CurlCbContextSyncTime
{
    PrivateInstanceAAMP *aamp;
    GrowableBuffer *buffer;
 
    CurlCbContextSyncTime() : aamp(NULL), buffer(NULL){}
    CurlCbContextSyncTime(PrivateInstanceAAMP *_aamp, GrowableBuffer *_buffer) : aamp(_aamp),buffer(_buffer){}
    ~CurlCbContextSyncTime() {}
 
    CurlCbContextSyncTime(const CurlCbContextSyncTime &other) = delete;
    CurlCbContextSyncTime& operator=(const CurlCbContextSyncTime& other) = delete;
};
 
/**
 * @brief Enumeration for net_srv_mgr active interface event callback
 */
typedef enum _NetworkManager_EventId_t {
        IARM_BUS_NETWORK_MANAGER_EVENT_SET_INTERFACE_ENABLED=50,
        IARM_BUS_NETWORK_MANAGER_EVENT_INTERFACE_IPADDRESS=55,
        IARM_BUS_NETWORK_MANAGER_MAX
} IARM_Bus_NetworkManager_EventId_t;
 
/**
 * @struct _IARM_BUS_NetSrvMgr_Iface_EventData_t
 * @brief IARM Bus struct contains active streaming interface, origional definition present in homenetworkingservice.h
 */
typedef struct _IARM_BUS_NetSrvMgr_Iface_EventData_t {
        union{
                char activeIface[10];
                char allNetworkInterfaces[50];
                char enableInterface[10];
        };
        char interfaceCount;
        bool isInterfaceEnabled;
} IARM_BUS_NetSrvMgr_Iface_EventData_t;
 
static TuneFailureMap tuneFailureMap[] =
{
        {AAMP_TUNE_INIT_FAILED, 10, "AAMP: init failed"}, //"Fragmentcollector initialization failed"
        {AAMP_TUNE_INIT_FAILED_MANIFEST_DNLD_ERROR, 10, "AAMP: init failed (unable to download manifest)"},
        {AAMP_TUNE_INIT_FAILED_MANIFEST_CONTENT_ERROR, 10, "AAMP: init failed (manifest missing tracks)"},
        {AAMP_TUNE_INIT_FAILED_MANIFEST_PARSE_ERROR, 10, "AAMP: init failed (corrupt/invalid manifest)"},
        {AAMP_TUNE_INIT_FAILED_PLAYLIST_VIDEO_DNLD_ERROR, 10, "AAMP: init failed (unable to download video playlist)"},
        {AAMP_TUNE_INIT_FAILED_PLAYLIST_AUDIO_DNLD_ERROR, 10, "AAMP: init failed (unable to download audio playlist)"},
        {AAMP_TUNE_INIT_FAILED_TRACK_SYNC_ERROR, 10, "AAMP: init failed (unsynchronized tracks)"},
        {AAMP_TUNE_MANIFEST_REQ_FAILED, 10, "AAMP: Manifest Download failed"}, //"Playlist refresh failed"
        {AAMP_TUNE_AUTHORISATION_FAILURE, 40, "AAMP: Authorization failure"},
        {AAMP_TUNE_FRAGMENT_DOWNLOAD_FAILURE, 10, "AAMP: fragment download failures"},
        {AAMP_TUNE_INIT_FRAGMENT_DOWNLOAD_FAILURE, 10, "AAMP: init fragment download failed"},
        {AAMP_TUNE_UNTRACKED_DRM_ERROR, 50, "AAMP: DRM error untracked error"},
        {AAMP_TUNE_DRM_INIT_FAILED, 50, "AAMP: DRM Initialization Failed"},
        {AAMP_TUNE_DRM_DATA_BIND_FAILED, 50, "AAMP: InitData-DRM Binding Failed"},
        {AAMP_TUNE_DRM_SESSIONID_EMPTY, 50, "AAMP: DRM Session ID Empty"},
        {AAMP_TUNE_DRM_CHALLENGE_FAILED, 50, "AAMP: DRM License Challenge Generation Failed"},
        {AAMP_TUNE_LICENCE_TIMEOUT, 50, "AAMP: DRM License Request Timed out"},
        {AAMP_TUNE_LICENCE_REQUEST_FAILED, 50, "AAMP: DRM License Request Failed"},
        {AAMP_TUNE_INVALID_DRM_KEY, 50, "AAMP: Invalid Key Error, from DRM"},
        {AAMP_TUNE_UNSUPPORTED_STREAM_TYPE, 60, "AAMP: Unsupported Stream Type"}, //"Unable to determine stream type for DRM Init"
        {AAMP_TUNE_UNSUPPORTED_AUDIO_TYPE, 60, "AAMP: No supported Audio Types in Manifest"},
        {AAMP_TUNE_FAILED_TO_GET_KEYID, 50, "AAMP: Failed to parse key id from PSSH"},
        {AAMP_TUNE_FAILED_TO_GET_ACCESS_TOKEN, 50, "AAMP: Failed to get access token from Auth Service"},
        {AAMP_TUNE_CORRUPT_DRM_DATA, 51, "AAMP: DRM failure due to Corrupt DRM files"},
        {AAMP_TUNE_CORRUPT_DRM_METADATA, 50, "AAMP: DRM failure due to Bad DRMMetadata in stream"},
        {AAMP_TUNE_DRM_DECRYPT_FAILED, 50, "AAMP: DRM Decryption Failed for Fragments"},
        {AAMP_TUNE_DRM_UNSUPPORTED, 50, "AAMP: DRM format Unsupported"},
        {AAMP_TUNE_DRM_SELF_ABORT, 50, "AAMP: DRM license request aborted by player"},
        {AAMP_TUNE_GST_PIPELINE_ERROR, 80, "AAMP: Error from gstreamer pipeline"},
        {AAMP_TUNE_PLAYBACK_STALLED, 7600, "AAMP: Playback was stalled due to lack of new fragments"},
        {AAMP_TUNE_CONTENT_NOT_FOUND, 20, "AAMP: Resource was not found at the URL(HTTP 404)"},
        {AAMP_TUNE_DRM_KEY_UPDATE_FAILED, 50, "AAMP: Failed to process DRM key"},
        {AAMP_TUNE_DEVICE_NOT_PROVISIONED, 52, "AAMP: Device not provisioned"},
        {AAMP_TUNE_HDCP_COMPLIANCE_ERROR, 53, "AAMP: HDCP Compliance Check Failure"},
        {AAMP_TUNE_INVALID_MANIFEST_FAILURE, 10, "AAMP: Invalid Manifest, parse failed"},
        {AAMP_TUNE_FAILED_PTS_ERROR, 80, "AAMP: Playback failed due to PTS error"},
        {AAMP_TUNE_MP4_INIT_FRAGMENT_MISSING, 10, "AAMP: init fragments missing in playlist"},
        {AAMP_TUNE_FAILURE_UNKNOWN, 100, "AAMP: Unknown Failure"}
};
 
static constexpr const char *BITRATECHANGE_STR[] =
{
        (const char *)"BitrateChanged - Network adaptation",                            // eAAMP_BITRATE_CHANGE_BY_ABR
        (const char *)"BitrateChanged - Rampdown due to network failure",               // eAAMP_BITRATE_CHANGE_BY_RAMPDOWN
        (const char *)"BitrateChanged - Reset to default bitrate due to tune",          // eAAMP_BITRATE_CHANGE_BY_TUNE
        (const char *)"BitrateChanged - Reset to default bitrate due to seek",          // eAAMP_BITRATE_CHANGE_BY_SEEK
        (const char *)"BitrateChanged - Reset to default bitrate due to trickplay",     // eAAMP_BITRATE_CHANGE_BY_TRICKPLAY
        (const char *)"BitrateChanged - Rampup since buffers are full",                 // eAAMP_BITRATE_CHANGE_BY_BUFFER_FULL
        (const char *)"BitrateChanged - Rampdown since buffers are empty",              // eAAMP_BITRATE_CHANGE_BY_BUFFER_EMPTY
        (const char *)"BitrateChanged - Network adaptation by FOG",                     // eAAMP_BITRATE_CHANGE_BY_FOG_ABR
        (const char *)"BitrateChanged - Information from OTA",                          // eAAMP_BITRATE_CHANGE_BY_OTA
        (const char *)"BitrateChanged - Video stream information from HDMIIN",          // eAAMP_BITRATE_CHANGE_BY_HDMIIN
        (const char *)"BitrateChanged - Unknown reason"                                 // eAAMP_BITRATE_CHANGE_MAX
};
 
#define BITRATEREASON2STRING(id) BITRATECHANGE_STR[id]
 
static constexpr const char *ADEVENT_STR[] =
{
        (const char *)"AAMP_EVENT_AD_RESERVATION_START",
        (const char *)"AAMP_EVENT_AD_RESERVATION_END",
        (const char *)"AAMP_EVENT_AD_PLACEMENT_START",
        (const char *)"AAMP_EVENT_AD_PLACEMENT_END",
        (const char *)"AAMP_EVENT_AD_PLACEMENT_ERROR",
        (const char *)"AAMP_EVENT_AD_PLACEMENT_PROGRESS"
};
 
#define ADEVENT2STRING(id) ADEVENT_STR[id - AAMP_EVENT_AD_RESERVATION_START]
 
static constexpr const char *mMediaFormatName[] =
{
    "HLS","DASH","PROGRESSIVE","HLS_MP4","OTA","HDMI_IN","COMPOSITE_IN","SMOOTH_STREAMING", "RMF", "UNKNOWN"
};
 
static_assert(sizeof(mMediaFormatName)/sizeof(mMediaFormatName[0]) == (eMEDIAFORMAT_UNKNOWN + 1), "Ensure 1:1 mapping between mMediaFormatName[] and enum MediaFormat");
/**
 * @brief Get the idle task's source ID
 * @retval source ID
 */
static guint aamp_GetSourceID()
{
        guint callbackId = 0;
        GSource *source = g_main_current_source();
        if (source != NULL)
        {
                callbackId = g_source_get_id(source);
        }
        return callbackId;
}
 
/**
 * @brief Idle task to resume aamp
 * @param ptr pointer to PrivateInstanceAAMP object
 * @retval True/False
 */
static gboolean PrivateInstanceAAMP_Resume(gpointer ptr)
{
        bool retValue = true;
        PrivateInstanceAAMP* aamp = (PrivateInstanceAAMP* )ptr;
        aamp->NotifyFirstBufferProcessed();
        TuneType tuneType = eTUNETYPE_SEEK;
 
        if (!aamp->mSeekFromPausedState && (aamp->rate == AAMP_NORMAL_PLAY_RATE))
        {
                retValue = aamp->mStreamSink->Pause(false, false);
                aamp->pipeline_paused = false;
        }
        else
        {
                // Live immediate : seek to live position from paused state.
                if (aamp->mPausedBehavior == ePAUSED_BEHAVIOR_LIVE_IMMEDIATE)
                {
                        tuneType = eTUNETYPE_SEEKTOLIVE;
                }
                aamp->rate = AAMP_NORMAL_PLAY_RATE;
                aamp->pipeline_paused = false;
                aamp->mSeekFromPausedState = false;
                aamp->AcquireStreamLock();
                aamp->TuneHelper(tuneType);
                aamp->ReleaseStreamLock();
        }
 
        aamp->ResumeDownloads();
        if(retValue)
        {
                aamp->NotifySpeedChanged(aamp->rate);
        }
        aamp->mAutoResumeTaskPending = false;
        return G_SOURCE_REMOVE;
}
 
/**
 * @brief Idle task to process discontinuity
 * @param ptr pointer to PrivateInstanceAAMP object
 * @retval G_SOURCE_REMOVE
 */
static gboolean PrivateInstanceAAMP_ProcessDiscontinuity(gpointer ptr)
{
        PrivateInstanceAAMP* aamp = (PrivateInstanceAAMP*) ptr;
 
        GSource *src = g_main_current_source();
        if (src == NULL || !g_source_is_destroyed(src))
        {
                bool ret = aamp->ProcessPendingDiscontinuity();
                // This is to avoid calling cond signal, in case Stop() interrupts the ProcessPendingDiscontinuity
                if (ret)
                {
                        aamp->SyncBegin();
                        aamp->mDiscontinuityTuneOperationId = 0;
                        aamp->SyncEnd();
                }
                pthread_cond_signal(&aamp->mCondDiscontinuity);
 
        }
        return G_SOURCE_REMOVE;
}
 
/**
 * @brief Tune again to currently viewing asset. Used for internal error handling
 * @param ptr pointer to PrivateInstanceAAMP object
 * @retval G_SOURCE_REMOVE
 */
static gboolean PrivateInstanceAAMP_Retune(gpointer ptr)
{
        PrivateInstanceAAMP* aamp = (PrivateInstanceAAMP*) ptr;
        bool activeAAMPFound = false;
        bool reTune = false;
        gActivePrivAAMP_t *gAAMPInstance = NULL;
        pthread_mutex_lock(&gMutex);
        for (std::list<gActivePrivAAMP_t>::iterator iter = gActivePrivAAMPs.begin(); iter != gActivePrivAAMPs.end(); iter++)
        {
                if (aamp == iter->pAAMP)
                {
                        gAAMPInstance = &(*iter);
                        activeAAMPFound = true;
                        reTune = gAAMPInstance->reTune;
                        break;
                }
        }
        if (!activeAAMPFound)
        {
                AAMPLOG_WARN("PrivateInstanceAAMP: %p not in Active AAMP list", aamp);
        }
        else if (!reTune)
        {
                AAMPLOG_WARN("PrivateInstanceAAMP: %p reTune flag not set", aamp);
        }
        else
        {
                if (aamp->pipeline_paused)
                {
                        aamp->pipeline_paused = false;
                }
 
                aamp->mIsRetuneInProgress = true;
                pthread_mutex_unlock(&gMutex);
 
                aamp->AcquireStreamLock();
                aamp->TuneHelper(eTUNETYPE_RETUNE);
                aamp->ReleaseStreamLock();
 
                pthread_mutex_lock(&gMutex);
                aamp->mIsRetuneInProgress = false;
                gAAMPInstance->reTune = false;
                pthread_cond_signal(&gCond);
        }
        pthread_mutex_unlock(&gMutex);
        return G_SOURCE_REMOVE;
}
 
 
/**
 * @brief Simulate VOD asset as a "virtual linear" stream.
 */
static void SimulateLinearWindow( struct GrowableBuffer *buffer, const char *ptr, size_t len )
{
        // Calculate elapsed time in seconds since virtual linear stream started
        float cull = (aamp_GetCurrentTimeMS() - simulation_start)/1000.0;
        buffer->len = 0; // Reset Growable Buffer length
        float window = 20.0; // Virtual live window size; can be increased/decreasedint
        const char *fin = ptr+len;
        bool wroteHeader = false; // Internal state used to decide whether HLS playlist header has already been output
        int seqNo = 0;
 
        while (ptr < fin)
        {
                int count = 0;
                char line[1024];
                float fragmentDuration;
 
                for(;;)
                {
                        char c = *ptr++;
                        line[count++] = c;
                        if( ptr>=fin || c<' ' ) break;
                }
 
                line[count] = 0x00;
 
                if (sscanf(line,"#EXTINF:%f",&fragmentDuration) == 1)
                {
                        if (cull > 0)
                        {
                                cull -= fragmentDuration;
                                seqNo++;
                                continue; // Not yet in active window
                        }
 
                        if (!wroteHeader)
                        {
                                // Write a simple linear HLS header, without the type:VOD, and with dynamic media sequence number
                                wroteHeader = true;
                                char header[1024];
                                snprintf( header, sizeof(header),
                                        "#EXTM3U\n"
                                        "#EXT-X-VERSION:3\n"
                                        "#EXT-X-TARGETDURATION:2\n"
                                        "#EXT-X-MEDIA-SEQUENCE:%d\n", seqNo );
                                aamp_AppendBytes(buffer, header, strlen(header) );
                        }
 
                        window -= fragmentDuration;
 
                        if (window < 0.0)
                        {
                                // Finished writing virtual linear window
                                break;
                        }
                }
 
                if (wroteHeader)
                {
                        aamp_AppendBytes(buffer, line, count );
                }
        }
 
        // Following can be used to debug
        // aamp_AppendNulTerminator( buffer );
        // printf( "Virtual Linear Playlist:\n%s\n***\n", buffer->ptr );
}
 
/**
 * @brief Get the telemetry type for a media type
 * @param type media type
 * @retval telemetry type
 */
static MediaTypeTelemetry aamp_GetMediaTypeForTelemetry(MediaType type)
{
        MediaTypeTelemetry ret;
        switch(type)
        {
                        case eMEDIATYPE_VIDEO:
                        case eMEDIATYPE_AUDIO:
                        case eMEDIATYPE_SUBTITLE:
                        case eMEDIATYPE_AUX_AUDIO:
                        case eMEDIATYPE_IFRAME:
                                                ret = eMEDIATYPE_TELEMETRY_AVS;
                                                break;
                        case eMEDIATYPE_MANIFEST:
                        case eMEDIATYPE_PLAYLIST_VIDEO:
                        case eMEDIATYPE_PLAYLIST_AUDIO:
                        case eMEDIATYPE_PLAYLIST_SUBTITLE:
                        case eMEDIATYPE_PLAYLIST_AUX_AUDIO:
                        case eMEDIATYPE_PLAYLIST_IFRAME:
                                                ret = eMEDIATYPE_TELEMETRY_MANIFEST;
                                                break;
                        case eMEDIATYPE_INIT_VIDEO:
                        case eMEDIATYPE_INIT_AUDIO:
                        case eMEDIATYPE_INIT_SUBTITLE:
                        case eMEDIATYPE_INIT_AUX_AUDIO:
                        case eMEDIATYPE_INIT_IFRAME:
                                                ret = eMEDIATYPE_TELEMETRY_INIT;
                                                break;
                        case eMEDIATYPE_LICENCE:
                                                ret = eMEDIATYPE_TELEMETRY_DRM;
                                                break;
                        default:
                                                ret = eMEDIATYPE_TELEMETRY_UNKNOWN;
                                                break;
        }
        return ret;
}
 
/**
 * @brief de-fog playback URL to play directly from CDN instead of fog
 * @param[in][out] dst Buffer containing URL
 */
static void DeFog(std::string& url)
{
        std::string prefix("&recordedUrl=");
        size_t startPos = url.find(prefix);
        if( startPos != std::string::npos )
        {
                startPos += prefix.size();
                size_t len = url.find( '&',startPos );
                if( len != std::string::npos )
                {
                        len -= startPos;
                }
                url = url.substr(startPos,len);
                aamp_DecodeUrlParameter(url);
        }
}
 
/**
 * @brief replace all occurrences of existingSubStringToReplace in str with replacementString
 * @param str string to be scanned/modified
 * @param existingSubStringToReplace substring to be replaced
 * @param replacementString string to be substituted
 * @retval true iff str was modified
 */
static bool replace(std::string &str, const char *existingSubStringToReplace, const char *replacementString)
{
        bool rc = false;
        std::size_t fromPos = 0;
        size_t existingSubStringToReplaceLen = 0;
        size_t replacementStringLen = 0;
        for(;;)
        {
                std::size_t pos = str.find(existingSubStringToReplace,fromPos);
                if( pos == std::string::npos )
                { // done - pattern not found
                        break;
                }
                if( !rc )
                { // lazily meaasure input strings - no need to measure unless match found
                        rc = true;
                        existingSubStringToReplaceLen = strlen(existingSubStringToReplace);
                        replacementStringLen = strlen(replacementString);
                }
                str.replace( pos, existingSubStringToReplaceLen, replacementString );
                fromPos  = pos + replacementStringLen;
        }
        return rc;
}
 
#ifdef IARM_MGR
 
/**
 * @brief Active interface state change from netsrvmgr
 * @param owner reference to net_srv_mgr
 * @param IARM eventId received
 * @data pointer reference to interface struct
 */
void getActiveInterfaceEventHandler (const char *owner, IARM_EventId_t eventId, void *data, size_t len)
{
 
        if (strcmp (owner, "NET_SRV_MGR") != 0)
                return;
 
        IARM_BUS_NetSrvMgr_Iface_EventData_t *param = (IARM_BUS_NetSrvMgr_Iface_EventData_t *) data;
 
        if (NULL == strstr (param->activeIface, previousInterface) || (strlen(previousInterface) == 0))
        {
                memset(previousInterface, 0, sizeof(previousInterface));
                strncpy(previousInterface, param->activeIface, sizeof(previousInterface) - 1);
                AAMPLOG_WARN("getActiveInterfaceEventHandler EventId %d activeinterface %s", eventId,  param->activeIface);
        }
 
        if (NULL != strstr (param->activeIface, "wlan"))
        {
                 activeInterfaceWifi = true;
        }
        else if (NULL != strstr (param->activeIface, "eth"))
        {
                 activeInterfaceWifi = false;
        }
}
#endif
 
/**
 * @brief convert https to https in recordedUrl part of manifestUrl
 * @param[in][out] dst Buffer containing URL
 * @param[in]string - https
 * @param[in]string - http
 */
void ForceHttpCoversionforFog(std::string& url,const std::string& from, const std::string& to)
{
        std::string prefix("&recordedUrl=");
        size_t startPos = url.find(prefix);
        if( startPos != std::string::npos )
        {
                startPos += prefix.size();
                url.replace(startPos, from.length(), to);
        }
}
/**
 * @brief Active streaming interface is wifi
 *
 * @return bool - true if wifi interface connected
 */
static bool IsActiveStreamingInterfaceWifi (void)
{
        bool wifiStatus = false;
#ifdef IARM_MGR
        IARM_Result_t ret = IARM_RESULT_SUCCESS;
        IARM_BUS_NetSrvMgr_Iface_EventData_t param;
 
        ret = IARM_Bus_Call("NET_SRV_MGR", "getActiveInterface", (void*)&param, sizeof(param));
        if (ret != IARM_RESULT_SUCCESS) {
                AAMPLOG_ERR("NET_SRV_MGR getActiveInterface read failed : %d", ret);
        }
        else
        {
                AAMPLOG_WARN("NET_SRV_MGR getActiveInterface = %s", param.activeIface);
                if (!strcmp(param.activeIface, "WIFI")){
                        wifiStatus = true;
                }
        }
        IARM_Bus_RegisterEventHandler("NET_SRV_MGR", IARM_BUS_NETWORK_MANAGER_EVENT_INTERFACE_IPADDRESS, getActiveInterfaceEventHandler);
#endif
        return wifiStatus;
}
 
/**
* @brief helper function to avoid dependency on unsafe sscanf while reading strings
* @param buf pointer to CString buffer to scan
* @param prefixPtr - prefix string to match in bufPtr
* @param valueCopyPtr receives allocated copy of string following prefix (skipping delimiting whitesace) if prefix found
* @retval 0 if prefix not present or error
* @retval 1 if string extracted/copied to valueCopyPtr
*/
static int ReadConfigStringHelper(std::string buf, const char *prefixPtr, const char **valueCopyPtr)
{
        int ret = 0;
        if (buf.find(prefixPtr) != std::string::npos)
        {
                std::size_t pos = strlen(prefixPtr);
                if (*valueCopyPtr != NULL)
                {
                        free((void *)*valueCopyPtr);
                        *valueCopyPtr = NULL;
                }
                *valueCopyPtr = strdup(buf.substr(pos).c_str());
                if (*valueCopyPtr)
                {
                        ret = 1;
                }
        }
        return ret;
}
 
/**
* @brief helper function to extract numeric value from given buf after removing prefix
* @param buf String buffer to scan
* @param prefixPtr - prefix string to match in bufPtr
* @param value - receives numeric value after extraction
* @retval 0 if prefix not present or error
* @retval 1 if string converted to numeric value
*/
template<typename T>
static int ReadConfigNumericHelper(std::string buf, const char* prefixPtr, T& value)
{
        int ret = 0;
 
        try
        {
                std::size_t pos = buf.rfind(prefixPtr,0); // starts with check
                if (pos != std::string::npos)
                {
                        pos += strlen(prefixPtr);
                        std::string valStr = buf.substr(pos);
                        if (std::is_same<T, int>::value)
                                value = std::stoi(valStr);
                        else if (std::is_same<T, long>::value)
                                value = std::stol(valStr);
                        else if (std::is_same<T, float>::value)
                                value = std::stof(valStr);
                        else
                                value = std::stod(valStr);
                        ret = 1;
                }
        }
        catch(exception& e)
        {
                // NOP
        }
 
        return ret;
}
 
 
// End of helper functions for loading configuration
 
 
static std::string getTimeStamp(time_t epochTime, const char* format = "%Y-%m-%dT%H:%M:%S.%f%Z")
{
   char timestamp[64] = {0};
   strftime(timestamp, sizeof(timestamp), format, localtime(&epochTime));
   return timestamp;
}
 
static time_t convertTimeToEpoch(const char* theTime, const char* format = "%Y-%m-%dT%H:%M:%S.%f%Z")
{
   std::tm tmTime;
   memset(&tmTime, 0, sizeof(tmTime));
   strptime(theTime, format, &tmTime);
   return mktime(&tmTime);
}
 
// Curl callback functions
 
/**
 * @brief write callback to be used by CURL
 * @param ptr pointer to buffer containing the data
 * @param size size of the buffer
 * @param nmemb number of bytes
 * @param userdata CurlCallbackContext pointer
 * @retval size consumed or 0 if interrupted
 */
static size_t SyncTime_write_callback(char *ptr, size_t size, size_t nmemb, void *userdata)
{
    size_t ret = 0;
    CurlCbContextSyncTime *context = (CurlCbContextSyncTime *)userdata;
    pthread_mutex_lock(&context->aamp->mLock);
    size_t numBytesForBlock = size*nmemb;
    aamp_AppendBytes(context->buffer, ptr, numBytesForBlock);
    ret = numBytesForBlock;
    pthread_mutex_unlock(&context->aamp->mLock);
    return ret;
}
 
/**
 * @brief HandleSSLWriteCallback - Handle write callback from CURL
 */
size_t PrivateInstanceAAMP::HandleSSLWriteCallback ( char *ptr, size_t size, size_t nmemb, void* userdata )
{
    size_t ret = 0;
    CurlCallbackContext *context = (CurlCallbackContext *)userdata;
    if(!context) return ret;
    pthread_mutex_lock(&context->aamp->mLock);
    if (context->aamp->mDownloadsEnabled)
    {
                if ((NULL == context->buffer->ptr) && (context->contentLength > 0))
                {
                        size_t len = context->contentLength + 2;
                        /*Add 2 additional characters to take care of extra characters inserted by aamp_AppendNulTerminator*/
                        if(context->downloadIsEncoded && (len < DEFAULT_ENCODED_CONTENT_BUFFER_SIZE))
                        {
                                // Allocate a fixed buffer for encoded contents. Content length is not trusted here
                                len = DEFAULT_ENCODED_CONTENT_BUFFER_SIZE;
                        }
                        assert(!context->buffer->ptr);
                        context->buffer->ptr = (char *)aamp_Malloc( len );
                        context->buffer->avail = len;
                }
        size_t numBytesForBlock = size*nmemb;
        aamp_AppendBytes(context->buffer, ptr, numBytesForBlock);
        ret = numBytesForBlock;
 
        if(context->aamp->GetLLDashServiceData()->lowLatencyMode &&
                 (context->fileType == eMEDIATYPE_VIDEO ||
                  context->fileType ==  eMEDIATYPE_AUDIO ||
                  context->fileType ==  eMEDIATYPE_SUBTITLE))
        {
                MediaStreamContext *mCtx = context->aamp->GetMediaStreamContext(context->fileType);
                if(mCtx)
                {
                        mCtx->CacheFragmentChunk(context->fileType, ptr, numBytesForBlock,context->remoteUrl,context->downloadStartTime);
                }
        }
    }
    else
    {
                if(ISCONFIGSET_PRIV(eAAMPConfig_EnableCurlStore) && mOrigManifestUrl.isRemotehost)
                {
                        ret = (size*nmemb);
                }
                else
                {
                        AAMPLOG_WARN("CurlTrace write_callback - interrupted, ret:%zu", ret);
                }
    }
    pthread_mutex_unlock(&context->aamp->mLock);
 
    return ret;
}
/**
 * @brief write callback to be used by CURL
 * @param ptr pointer to buffer containing the data
 * @param size size of the buffer
 * @param nmemb number of bytes
 * @param userdata CurlCallbackContext pointer
 * @retval size consumed or 0 if interrupted
 */
static size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata)
{
    size_t ret = 0;
    CurlCallbackContext *context = (CurlCallbackContext *)userdata;
    if(!context) return ret;
 
        ret = context->aamp->HandleSSLWriteCallback( ptr, size, nmemb, userdata);
    return ret;
}
 
/**
 * @brief function to print header response during download failure and latency.
 * @param fileType current media type
 */
static void print_headerResponse(std::vector<std::string> &allResponseHeadersForErrorLogging, MediaType fileType)
{
        if (gpGlobalConfig->logging.curlHeader && (eMEDIATYPE_VIDEO == fileType || eMEDIATYPE_PLAYLIST_VIDEO == fileType))
        {
                int size = allResponseHeadersForErrorLogging.size();
                AAMPLOG_WARN("################ Start :: Print Header response ################");
                for (int i=0; i < size; i++)
                {
                        AAMPLOG_WARN("* %s", allResponseHeadersForErrorLogging.at(i).c_str());
                }
                AAMPLOG_WARN("################ End :: Print Header response ################");
        }
 
        allResponseHeadersForErrorLogging.clear();
}
 
/**
 * @brief HandleSSLHeaderCallback - Hanlde header callback from SSL
 */
size_t PrivateInstanceAAMP::HandleSSLHeaderCallback ( const char *ptr, size_t size, size_t nmemb, void* user_data )
{
        CurlCallbackContext *context = static_cast<CurlCallbackContext *>(user_data);
        httpRespHeaderData *httpHeader = context->responseHeaderData;
        size_t len = nmemb * size;
        size_t startPos = 0;
        size_t endPos = len-2; // strip CRLF
 
        bool isBitrateHeader = false;
        bool isFogRecordingIdHeader = false;
        bool isProfileCapHeader = false;
 
        if( len<2 || ptr[endPos] != '\r' || ptr[endPos+1] != '\n' )
        { // only proceed if this is a CRLF terminated curl header, as expected
                return len;
        }
 
        if (context->aamp->mConfig->IsConfigSet(eAAMPConfig_CurlHeader) && ptr[0] &&
                (eMEDIATYPE_VIDEO == context->fileType || eMEDIATYPE_PLAYLIST_VIDEO == context->fileType))
        {
                std::string temp = std::string(ptr,endPos);
                context->allResponseHeadersForErrorLogging.push_back(temp);
        }
 
        // As per Hypertext Transfer Protocol ==> Field names are case-insensitive
        // HTTP/1.1 4.2 Message Headers : Each header field consists of a name followed by a colon (":") and the field value. Field names are case-insensitive
        if (STARTS_WITH_IGNORE_CASE(ptr, FOG_REASON_STRING))
        {
                httpHeader->type = eHTTPHEADERTYPE_FOG_REASON;
                startPos = STRLEN_LITERAL(FOG_REASON_STRING);
        }
        else if (STARTS_WITH_IGNORE_CASE(ptr, CURLHEADER_X_REASON))
        {
                httpHeader->type = eHTTPHEADERTYPE_XREASON;
                startPos = STRLEN_LITERAL(CURLHEADER_X_REASON);
        }
        else if (STARTS_WITH_IGNORE_CASE(ptr, BITRATE_HEADER_STRING))
        {
                startPos = STRLEN_LITERAL(BITRATE_HEADER_STRING);
                isBitrateHeader = true;
        }
        else if (STARTS_WITH_IGNORE_CASE(ptr, SET_COOKIE_HEADER_STRING))
        {
                httpHeader->type = eHTTPHEADERTYPE_COOKIE;
                startPos = STRLEN_LITERAL(SET_COOKIE_HEADER_STRING);
        }
        else if (STARTS_WITH_IGNORE_CASE(ptr, LOCATION_HEADER_STRING))
        {
                httpHeader->type = eHTTPHEADERTYPE_EFF_LOCATION;
                startPos = STRLEN_LITERAL(LOCATION_HEADER_STRING);
        }
        else if (STARTS_WITH_IGNORE_CASE(ptr, FOG_RECORDING_ID_STRING))
        {
                startPos = STRLEN_LITERAL(FOG_RECORDING_ID_STRING);
                isFogRecordingIdHeader = true;
        }
        else if (STARTS_WITH_IGNORE_CASE(ptr, CONTENT_ENCODING_STRING ))
        {
                // Enabled IsEncoded as Content-Encoding header is present
                // The Content-Encoding entity header incidcates media is compressed
                context->downloadIsEncoded = true;
        }
        else if (context->aamp->mConfig->IsConfigSet(eAAMPConfig_LimitResolution) && context->aamp->IsFirstRequestToFog() && STARTS_WITH_IGNORE_CASE(ptr, CAPPED_PROFILE_STRING ))
        {
                startPos = STRLEN_LITERAL(CAPPED_PROFILE_STRING);
                isProfileCapHeader = true;
        }
        else if (STARTS_WITH_IGNORE_CASE(ptr, TRANSFER_ENCODING_STRING ))
        {
                context->chunkedDownload = true;
        }
        else if (0 == context->buffer->avail)
        {
                if (STARTS_WITH_IGNORE_CASE(ptr, CONTENTLENGTH_STRING))
                {
                        int contentLengthStartPosition = STRLEN_LITERAL(CONTENTLENGTH_STRING);
                        const char * contentLengthStr = ptr + contentLengthStartPosition;
                        context->contentLength = atoi(contentLengthStr);
                }
        }
 
        // Check for http header tags, only if event listener for HTTPResponseHeaderEvent is available
        if (eMEDIATYPE_MANIFEST == context->fileType && context->aamp->IsEventListenerAvailable(AAMP_EVENT_HTTP_RESPONSE_HEADER))
        {
                std::vector<std::string> responseHeaders = context->aamp->responseHeaders;
 
                if (responseHeaders.size() > 0)
                {
                        for (int header=0; header < responseHeaders.size(); header++) {
                                std::string headerType = responseHeaders[header].c_str();
                                // check if subscribed header is available
                                if (0 == strncasecmp(ptr, headerType.c_str() , headerType.length()))
                                {
                                        startPos = headerType.length();
                                        // strip only the header value from the response
                                        context->aamp->httpHeaderResponses[headerType] = std::string( ptr + startPos + 2, endPos - startPos - 2).c_str();
                                        AAMPLOG_INFO("httpHeaderResponses");
                                        for (auto const& pair: context->aamp->httpHeaderResponses) {
                                                AAMPLOG_INFO("{ %s, %s }", pair.first.c_str(), pair.second.c_str());
                                        }
                                }
                        }
                }
        }
 
        if(startPos > 0)
        {
                while( endPos>startPos && ptr[endPos-1] == ' ' )
                { // strip trailing whitespace
                        endPos--;
                }
                while( startPos < endPos && ptr[startPos] == ' ')
                { // strip leading whitespace
                        startPos++;
                }
 
                if(isBitrateHeader)
                {
                        const char * strBitrate = ptr + startPos;
                        context->bitrate = atol(strBitrate);
                        AAMPLOG_TRACE("Parsed HTTP %s: %ld", isBitrateHeader? "Bitrate": "False", context->bitrate);
                }
                else if(isFogRecordingIdHeader)
                {
                        context->aamp->mTsbRecordingId = string( ptr + startPos, endPos - startPos );
                        AAMPLOG_TRACE("Parsed Fog-Id : %s", context->aamp->mTsbRecordingId.c_str());
                }
                else if(isProfileCapHeader)
                {
                        const char * strProfileCap = ptr + startPos;
                        context->aamp->mProfileCappedStatus = atol(strProfileCap)? true : false;
                        AAMPLOG_TRACE("Parsed Profile-Capped Header : %d", context->aamp->mProfileCappedStatus);
                }
                else
                {
                        httpHeader->data = string( ptr + startPos, endPos - startPos );
                        if(httpHeader->type != eHTTPHEADERTYPE_EFF_LOCATION)
                        { //Append delimiter ";"
                                httpHeader->data += ';';
                        }
                }
 
                if(gpGlobalConfig->logging.trace)
                {
                        AAMPLOG_TRACE("Parsed HTTP %s header: %s", httpHeader->type==eHTTPHEADERTYPE_COOKIE? "Cookie": "X-Reason", httpHeader->data.c_str());
                }
        }
 
        return len;
}
 
/**
 * @brief Convert to string and add suffix k, M, G
 * @param bps bytes Speed
 * @param str ptr String buffer
 * @retval ptr Converted String buffer
 */
char* ConvertSpeedToStr(long bps, char *str)
{
    #define ONE_KILO  1024
    #define ONE_MEGA ((1024) * ONE_KILO)
 
    if(bps < 100000)
        snprintf(str, 6, "%5ld", bps);
 
    else if(bps < (10000 * ONE_KILO))
      snprintf(str, 6, "%4ld" "k", bps/ONE_KILO);
 
    else if(bps < (100 * ONE_MEGA))
        snprintf(str, 6, "%2ld" ".%0ld" "M", bps/ONE_MEGA,
            (bps%ONE_MEGA) / (ONE_MEGA/10) );
    else
      snprintf(str, 6, "%4ld" "M", bps/ONE_MEGA);
 
    return str;
}
 
 
/**
 * @brief Get Current Content Download Speed
 * @param aamp ptr aamp context
 * @param fileType File Type
 * @param bDownloadStart Download start flag
 * @param start Download start time
 * @param dlnow current downloaded bytes
 * @retval bps bits per second
 */
long getCurrentContentDownloadSpeed(PrivateInstanceAAMP *aamp,
                                    MediaType fileType, //File Type Download
                                    bool bDownloadStart,
                                    long start,
                                    double dlnow) // downloaded bytes so far)
{
    long bitsPerSecond = 0;
    long time_now = 0;
    long time_diff = 0;
    long dl_diff = 0;
    char buffer[2][6] = {0,};
 
    struct SpeedCache* speedcache = NULL;
    speedcache = aamp->GetLLDashSpeedCache();
 
    if(!aamp->mhAbrManager.GetLowLatencyStartABR())
    {
        speedcache->last_sample_time_val = start;
    }
 
    time_now = NOW_STEADY_TS_MS;
    time_diff = (time_now - speedcache->last_sample_time_val);
 
    if(bDownloadStart)
    {
        speedcache->prev_dlnow = 0;
    }
 
    dl_diff = (long)dlnow -  speedcache->prev_dlnow;
 
    long prevdlnow = speedcache->prev_dlnow;
    speedcache->prev_dlnow = dlnow;
 
    long currentTotalDownloaded = 0;
    long total_dl_diff  = 0;
    currentTotalDownloaded = speedcache->totalDownloaded + dl_diff;
    total_dl_diff = currentTotalDownloaded - speedcache->prevSampleTotalDownloaded;
    if(total_dl_diff<=0) total_dl_diff = 0;
 
    //AAMPLOG_INFO("[%d] prev_dlnow: %ld dlnow: %ld dl_diff: %ld total_dl_diff: %ld Current Total Download: %ld Previous Total Download: %ld",fileType, prevdlnow, (long)dlnow, dl_diff,total_dl_diff,currentTotalDownloaded, speedcache->prevSampleTotalDownloaded);
 
    if(aamp->mhAbrManager.IsABRDataGoodToEstimate(time_diff))
    {
            aamp->mhAbrManager.CheckLLDashABRSpeedStoreSize(speedcache,bitsPerSecond,time_now,total_dl_diff,time_diff,currentTotalDownloaded);
    }
    else
    {
        AAMPLOG_TRACE("[%d] Ignore Speed Calculation -> time_diff [%ld]",fileType, time_diff);
    }
    
    speedcache->totalDownloaded += dl_diff;
    
    return bitsPerSecond;
}
 
/**
 * @brief HandleSSLProgressCallback - Process progress callback from CURL
 *
 * @param clientp opaque context passed by caller
 * @param dltotal total number of bytes libcurl expects to download
 * @param dlnow number of bytes downloaded so far
 * @param ultotal total number of bytes libcurl expects to upload
 * @param ulnow number of bytes uploaded so far
 *
 * @retval -1 to cancel in progress download
 */
int PrivateInstanceAAMP::HandleSSLProgressCallback ( void *clientp, double dltotal, double dlnow, double ultotal, double ulnow )
{
        CurlProgressCbContext *context = (CurlProgressCbContext *)clientp;
        PrivateInstanceAAMP *aamp = context->aamp;
        AampConfig *mConfig = context->aamp->mConfig;
 
        if(context->aamp->GetLLDashServiceData()->lowLatencyMode &&
                context->fileType == eMEDIATYPE_VIDEO &&
                context->aamp->CheckABREnabled() &&
                !(ISCONFIGSET_PRIV(eAAMPConfig_DisableLowLatencyABR)))
        {
                //AAMPLOG_WARN("[%d] dltotal: %.0f , dlnow: %.0f, ultotal: %.0f, ulnow: %.0f, time: %.0f\n", context->fileType,
                //      dltotal, dlnow, ultotal, ulnow, difftime(time(NULL), 0));
 
                int  AbrChunkThresholdSize = 0;
                GETCONFIGVALUE(eAAMPConfig_ABRChunkThresholdSize,AbrChunkThresholdSize);
 
                if (/*(dlnow > AbrChunkThresholdSize) &&*/ (context->downloadNow != dlnow))
                {
                        long downloadbps = 0;
 
                        context->downloadNow = dlnow;
                        context->downloadNowUpdatedTime = NOW_STEADY_TS_MS;
 
                        if(!aamp->mhAbrManager.GetLowLatencyStartABR())
                        {
                                //Reset speedcache when Fragment download Starts
                                struct SpeedCache* speedcache = NULL;
                                speedcache = aamp->GetLLDashSpeedCache();
                                memset(speedcache, 0x00, sizeof(struct SpeedCache));
                        }
 
                        downloadbps = getCurrentContentDownloadSpeed(aamp, context->fileType, context->dlStarted, (long)context->downloadStartTime, dlnow);
 
                        if(context->dlStarted)
                        {
                                context->dlStarted = false;
                        }
 
                        if(!aamp->mhAbrManager.GetLowLatencyStartABR())
                        {
                                aamp->mhAbrManager.SetLowLatencyStartABR(true);
                        }
 
                        if(downloadbps)
                        {
                                long currentProfilebps  = context->aamp->mpStreamAbstractionAAMP->GetVideoBitrate();
 
                                pthread_mutex_lock(&context->aamp->mLock);
                                aamp->mhAbrManager.UpdateABRBitrateDataBasedOnCacheLength(context->aamp->mAbrBitrateData,downloadbps,true);
                                pthread_mutex_unlock(&context->aamp->mLock);
                        }
                }
        }
 
        int rc = 0;
        context->aamp->SyncBegin();
        if (!context->aamp->mDownloadsEnabled)
        {
                rc = -1; // CURLE_ABORTED_BY_CALLBACK
        }
 
        context->aamp->SyncEnd();
        if( rc==0 )
        { // only proceed if not an aborted download
                if (dlnow > 0 && context->stallTimeout > 0)
                {
                        if (context->downloadSize == -1)
                        { // first byte(s) downloaded
                                context->downloadSize = dlnow;
                                context->downloadUpdatedTime = NOW_STEADY_TS_MS;
                        }
                        else
                        {
                                if (dlnow == context->downloadSize)
                                { // no change in downloaded bytes - check time since last update to infer stall
                                        double timeElapsedSinceLastUpdate = (NOW_STEADY_TS_MS - context->downloadUpdatedTime) / 1000.0; //in secs
                                        if (timeElapsedSinceLastUpdate >= context->stallTimeout)
                                        { // no change for at least <stallTimeout> seconds - consider download stalled and abort
                                                AAMPLOG_WARN("Abort download as mid-download stall detected for %.2f seconds, download size:%.2f bytes", timeElapsedSinceLastUpdate, dlnow);
                                                context->abortReason = eCURL_ABORT_REASON_STALL_TIMEDOUT;
                                                rc = -1;
                                        }
                                }
                                else
                                { // received additional bytes - update state to track new size/time
                                        context->downloadSize = dlnow;
                                        context->downloadUpdatedTime = NOW_STEADY_TS_MS;
                                }
                        }
                }
                if (dlnow == 0 && context->startTimeout > 0)
                { // check to handle scenario where <startTimeout> seconds delay occurs without any bytes having been downloaded (stall at start)
                        double timeElapsedInSec = (double)(NOW_STEADY_TS_MS - context->downloadStartTime) / 1000; //in secs  //CID:85922 - UNINTENDED_INTEGER_DIVISION
                        if (timeElapsedInSec >= context->startTimeout)
                        {
                                AAMPLOG_WARN("Abort download as no data received for %.2f seconds", timeElapsedInSec);
                                context->abortReason = eCURL_ABORT_REASON_START_TIMEDOUT;
                                rc = -1;
                        }
                }
                if (dlnow > 0 && context->lowBWTimeout> 0 && eMEDIATYPE_VIDEO == context->fileType)
                {
                        double elapsedTimeMs = (double)(NOW_STEADY_TS_MS - context->downloadStartTime);
                        if( elapsedTimeMs >= context->lowBWTimeout*1000 )
                        {
                                double predictedTotalDownloadTimeMs = elapsedTimeMs*dltotal/dlnow;
                                if( predictedTotalDownloadTimeMs > aamp->mNetworkTimeoutMs )
                                {
                                        AAMPLOG_WARN("lowBWTimeout=%lds; predictedTotalDownloadTime=%fs>%fs (network timeout)",
                                                                 context->lowBWTimeout,
                                                                 predictedTotalDownloadTimeMs/1000.0,
                                                                 aamp->mNetworkTimeoutMs/1000.0 );
                                        context->abortReason = eCURL_ABORT_REASON_LOW_BANDWIDTH_TIMEDOUT;
                                        rc = -1;
                                }
                        }
                }
        }
 
        if(rc)
        {
                if( !( eCURL_ABORT_REASON_LOW_BANDWIDTH_TIMEDOUT == context->abortReason || eCURL_ABORT_REASON_START_TIMEDOUT == context->abortReason ||\
                        eCURL_ABORT_REASON_STALL_TIMEDOUT == context->abortReason ) && (ISCONFIGSET_PRIV(eAAMPConfig_EnableCurlStore) && mOrigManifestUrl.isRemotehost ) )
                {
                        rc = 0;
                }
                else
                {
                        AAMPLOG_WARN("CurlTrace Progress interrupted, ret:%d", rc);
                }
        }
        return rc;
}
 
/**
 * @brief
 * @param clientp app-specific as optionally set with CURLOPT_PROGRESSDATA
 * @param dltotal total bytes expected to download
 * @param dlnow downloaded bytes so far
 * @param ultotal total bytes expected to upload
 * @param ulnow uploaded bytes so far
 * @retval
 */
static int progress_callback(
        void *clientp, // app-specific as optionally set with CURLOPT_PROGRESSDATA
        double dltotal, // total bytes expected to download
        double dlnow, // downloaded bytes so far
        double ultotal, // total bytes expected to upload
        double ulnow // uploaded bytes so far
        )
{
        CurlProgressCbContext *context = (CurlProgressCbContext *)clientp;
 
        return context->aamp->HandleSSLProgressCallback ( clientp, dltotal, dlnow, ultotal, ulnow );
}
 
// End of curl callback functions
 
/**
 * @brief PrivateInstanceAAMP Constructor
 */
PrivateInstanceAAMP::PrivateInstanceAAMP(AampConfig *config) : mReportProgressPosn(0.0), mAbrBitrateData(), mLock(), mMutexAttr(),
        mpStreamAbstractionAAMP(NULL), mInitSuccess(false), mVideoFormat(FORMAT_INVALID), mAudioFormat(FORMAT_INVALID), mDownloadsDisabled(),
        mDownloadsEnabled(true), mStreamSink(NULL), profiler(), licenceFromManifest(false), previousAudioType(eAUDIO_UNKNOWN),isPreferredDRMConfigured(false),
        mbDownloadsBlocked(false), streamerIsActive(false), mTSBEnabled(false), mIscDVR(false), mLiveOffset(AAMP_LIVE_OFFSET),
        seek_pos_seconds(-1), rate(0), pipeline_paused(false), mMaxLanguageCount(0), zoom_mode(VIDEO_ZOOM_FULL),
        video_muted(false), subtitles_muted(true), audio_volume(100), subscribedTags(), responseHeaders(), httpHeaderResponses(), timedMetadata(), timedMetadataNew(), IsTuneTypeNew(false), trickStartUTCMS(-1),mLogTimetoTopProfile(true),
        durationSeconds(0.0), culledSeconds(0.0), culledOffset(0.0), maxRefreshPlaylistIntervalSecs(DEFAULT_INTERVAL_BETWEEN_PLAYLIST_UPDATES_MS/1000),
        mEventListener(NULL), mNewSeekInfo(), discardEnteringLiveEvt(false),
        mIsRetuneInProgress(false), mCondDiscontinuity(), mDiscontinuityTuneOperationId(0), mIsVSS(false),
        m_fd(-1), mIsLive(false), mIsAudioContextSkipped(false), mLogTune(false), mTuneCompleted(false), mFirstTune(true), mfirstTuneFmt(-1), mTuneAttempts(0), mPlayerLoadTime(0),
        mState(eSTATE_RELEASED), mMediaFormat(eMEDIAFORMAT_HLS), mPersistedProfileIndex(0), mAvailableBandwidth(0),
        mDiscontinuityTuneOperationInProgress(false), mContentType(ContentType_UNKNOWN), mTunedEventPending(false),
        mSeekOperationInProgress(false), mTrickplayInProgress(false), mPendingAsyncEvents(), mCustomHeaders(),
        mCMCDNextObjectRequest(""),mCMCDBandwidth(0),
        mManifestUrl(""), mTunedManifestUrl(""), mOrigManifestUrl(), mServiceZone(), mVssVirtualStreamId(),
        mCurrentLanguageIndex(0),
        preferredLanguagesString(), preferredLanguagesList(), preferredLabelList(),mhAbrManager(),
        mVideoEnd(NULL),
        mTimeToTopProfile(0),mTimeAtTopProfile(0),mPlaybackDuration(0),mTraceUUID(),
        mIsFirstRequestToFOG(false),
        mPausePositionMonitorMutex(), mPausePositionMonitorCV(), mPausePositionMonitoringThreadID(), mPausePositionMonitoringThreadStarted(false),
        mTuneType(eTUNETYPE_NEW_NORMAL)
        ,mCdaiObject(NULL), mAdEventsQ(),mAdEventQMtx(), mAdPrevProgressTime(0), mAdCurOffset(0), mAdDuration(0), mAdProgressId("")
        ,mBufUnderFlowStatus(false), mVideoBasePTS(0)
        ,mCustomLicenseHeaders(), mIsIframeTrackPresent(false), mManifestTimeoutMs(-1), mNetworkTimeoutMs(-1)
        ,mbPlayEnabled(true), mPlayerPreBuffered(false), mPlayerId(PLAYERID_CNTR++),mAampCacheHandler(NULL)
        ,mAsyncTuneEnabled(false) 
        ,waitforplaystart() 
        ,mCurlShared(NULL)
        ,mDrmDecryptFailCount(MAX_SEG_DRM_DECRYPT_FAIL_COUNT)
        ,mPlaylistTimeoutMs(-1)
        ,mMutexPlaystart()
#ifdef AAMP_HLS_DRM
    , fragmentCdmEncrypted(false) ,drmParserMutex(), aesCtrAttrDataList()
        , drmSessionThreadStarted(false), createDRMSessionThreadID(0)
#endif
#if defined(AAMP_MPD_DRM) || defined(AAMP_HLS_DRM)
        , mDRMSessionManager(NULL)
#endif
        ,  mPreCachePlaylistThreadId(0), mPreCachePlaylistThreadFlag(false) , mPreCacheDnldList()
        , mPreCacheDnldTimeWindow(0), mParallelPlaylistFetchLock(), mAppName()
        , mProgressReportFromProcessDiscontinuity(false)
        , mPlaylistFetchFailError(0L),mAudioDecoderStreamSync(true)
        , mPrevPositionMilliseconds()
        , mGetPositionMillisecondsMutexHard()
        , mGetPositionMillisecondsMutexSoft()
        , mPausePositionMilliseconds(AAMP_PAUSE_POSITION_INVALID_POSITION)
        , mCurrentDrm(), mDrmInitData(), mMinInitialCacheSeconds(DEFAULT_MINIMUM_INIT_CACHE_SECONDS)
        //, mLicenseServerUrls()
        , mFragmentCachingRequired(false), mFragmentCachingLock()
        , mPauseOnFirstVideoFrameDisp(false)
        , mPreferredTextTrack(), mFirstVideoFrameDisplayedEnabled(false)
        , mSessionToken() 
        , vDynamicDrmData()
        , midFragmentSeekCache(false)
        , mPreviousAudioType (FORMAT_INVALID)
        , mTsbRecordingId()
        , mthumbIndexValue(-1)
        , mManifestRefreshCount (0)
        , mJumpToLiveFromPause(false), mPausedBehavior(ePAUSED_BEHAVIOR_AUTOPLAY_IMMEDIATE), mSeekFromPausedState(false)
        , mProgramDateTime (0), mMPDPeriodsInfo()
        , mProfileCappedStatus(false),mSchemeIdUriDai("")
        , mDisplayWidth(0)
        , mDisplayHeight(0)
        , preferredRenditionString("")
        , preferredRenditionList()
        , preferredTypeString("")
        , preferredCodecString("")
        , preferredCodecList()
        , mAudioTuple()
        , preferredLabelsString("")
        , preferredAudioAccessibilityNode()
        , preferredTextLanguagesString("")
        , preferredTextLanguagesList()
        , preferredTextRenditionString("")
        , preferredTextTypeString("")
        , preferredTextLabelString("")
        , preferredTextAccessibilityNode()
        , mProgressReportOffset(-1)
        , mAutoResumeTaskId(AAMP_TASK_ID_INVALID), mAutoResumeTaskPending(false), mScheduler(NULL), mEventLock(), mEventPriority(G_PRIORITY_DEFAULT_IDLE)
        , mStreamLock()
        , mConfig (config),mSubLanguage(), mHarvestCountLimit(0), mHarvestConfig(0)
        , mIsWVKIDWorkaround(false)
        , mAuxFormat(FORMAT_INVALID), mAuxAudioLanguage()
        , mAbsoluteEndPosition(0), mIsLiveStream(false)
        , mbUsingExternalPlayer (false)
        , mCCId(0)
        , seiTimecode()
        , contentGaps()
        , mAampLLDashServiceData{}
        , bLowLatencyServiceConfigured(false)
        , bLLDashAdjustPlayerSpeed(false)
        , mLLDashCurrentPlayRate(AAMP_NORMAL_PLAY_RATE)
        , vidTimeScale(0)
        , audTimeScale(0)
        , speedCache {}
        , mTime (0)
        , mCurrentLatency(0)
        , mLiveOffsetAppRequest(false)
        , bLowLatencyStartABR(false)
        , mWaitForDiscoToComplete()
        , mDiscoCompleteLock()
        , mIsPeriodChangeMarked(false)
        , mLogObj(NULL)
        , mEventManager (NULL)
        , mbDetached(false)
        , mIsFakeTune(false)
        , mCurrentAudioTrackId(-1)
        , mCurrentVideoTrackId(-1)
        , mIsTrackIdMismatch(false)
        , mIsDefaultOffset(false)
        , mNextPeriodDuration(0)
        , mNextPeriodStartTime(0)
        , mNextPeriodScaledPtoStartTime(0)
        , mOffsetFromTunetimeForSAPWorkaround(0)
        , mLanguageChangeInProgress(false)
        , mSupportedTLSVersion(0)
        , mbSeeked(false)
        , mFailureReason("")
        , mTimedMetadataStartTime(0)
        , mTimedMetadataDuration(0)
        , playerStartedWithTrickPlay(false)
        , mPlaybackMode("UNKNOWN")
        , mApplyVideoRect(false)
        , mVideoRect{}
        , mData(NULL)
        , mIsInbandCC(true)
        , bitrateList()
        , userProfileStatus(false)
        , mApplyCachedVideoMute(false)
        , mFirstProgress(false)
        , mTsbSessionRequestUrl()
        , mcurrent_keyIdArray()
        , mDynamicDrmDefaultconfig()
        , mWaitForDynamicDRMToUpdate()
        , mDynamicDrmUpdateLock()
        , mDynamicDrmCache()
        , mAudioComponentCount(-1)
        , mVideoComponentCount(-1)
        , mAudioOnlyPb(false)
        , mVideoOnlyPb(false)
        , mCurrentAudioTrackIndex(-1)
        , mCurrentTextTrackIndex(-1)
        , playerrate(1.0)
        , mSetPlayerRateAfterFirstframe(false)
        , mEncryptedPeriodFound(false)
        , mPipelineIsClear(false)
        , mLLActualOffset(-1)
        , mIsStream4K(false)
        , mTextStyle()
{
        for(int i=0; i<eMEDIATYPE_DEFAULT; i++)
        {
                lastId3Data[i] = NULL;
                lastId3DataLen[i] = 0;
        }
        mLogObj = mConfig->GetLoggerInstance();
        //LazilyLoadConfigIfNeeded();
        mAampCacheHandler = new AampCacheHandler(mConfig->GetLoggerInstance());
#ifdef AAMP_CC_ENABLED
        AampCCManager::GetInstance()->SetLogger(mConfig->GetLoggerInstance());
#endif
        profiler.SetLogger(mConfig->GetLoggerInstance());
        // Create the event manager for player instance 
        mEventManager = new AampEventManager(mLogObj);
        SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_UserAgent, (std::string )AAMP_USERAGENT_BASE_STRING);
        int maxDrmSession;
        GETCONFIGVALUE_PRIV(eAAMPConfig_MaxDASHDRMSessions,maxDrmSession);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredAudioLanguage,preferredLanguagesString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredAudioRendition,preferredRenditionString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredAudioCodec,preferredCodecString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredAudioLabel,preferredLabelsString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredAudioType,preferredTypeString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredTextRendition,preferredTextRenditionString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredTextLanguage,preferredTextLanguagesString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredTextLabel,preferredTextLabelString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredTextType,preferredTextTypeString);
#if defined(AAMP_MPD_DRM) || defined(AAMP_HLS_DRM)
        mDRMSessionManager = new AampDRMSessionManager(mLogObj, maxDrmSession);
#endif
        pthread_cond_init(&mDownloadsDisabled, NULL);
        GETCONFIGVALUE_PRIV(eAAMPConfig_SubTitleLanguage,mSubLanguage); 
        pthread_mutexattr_init(&mMutexAttr);
        pthread_mutexattr_settype(&mMutexAttr, PTHREAD_MUTEX_RECURSIVE);
        pthread_mutex_init(&mLock, &mMutexAttr);
        pthread_mutex_init(&mParallelPlaylistFetchLock, &mMutexAttr);
        pthread_mutex_init(&mFragmentCachingLock, &mMutexAttr);
        pthread_mutex_init(&mEventLock, &mMutexAttr);
        pthread_mutex_init(&mDynamicDrmUpdateLock,&mMutexAttr);
        pthread_mutex_init(&mStreamLock, &mMutexAttr);
        pthread_mutex_init(&mDiscoCompleteLock,&mMutexAttr);
 
        for (int i = 0; i < eCURLINSTANCE_MAX; i++)
        {
                curl[i] = NULL;
                //cookieHeaders[i].clear();
                httpRespHeaders[i].type = eHTTPHEADERTYPE_UNKNOWN;
                httpRespHeaders[i].data.clear();
                curlDLTimeout[i] = 0;
        }
 
        if( ISCONFIGSET_PRIV(eAAMPConfig_EnableCurlStore) )
        {
                for (int i = 0; i < eCURLINSTANCE_MAX; i++)
                {
                        curlhost[i] = new eCurlHostMap();
                }
        }
 
        for (int i = 0; i < AAMP_TRACK_COUNT; i++)
        {
                mbTrackDownloadsBlocked[i] = false;
                mTrackInjectionBlocked[i] = false;
                lastUnderFlowTimeMs[i] = 0;
                mProcessingDiscontinuity[i] = false;
                mIsDiscontinuityIgnored[i] = false;
        }
 
        pthread_mutex_lock(&gMutex);
        gActivePrivAAMP_t gAAMPInstance = { this, false, 0 };
        gActivePrivAAMPs.push_back(gAAMPInstance);
        pthread_mutex_unlock(&gMutex);
        mPendingAsyncEvents.clear();
 
        if (ISCONFIGSET_PRIV(eAAMPConfig_WifiCurlHeader)) {
                if (true == IsActiveStreamingInterfaceWifi()) {
                        mCustomHeaders["Wifi:"] = std::vector<std::string> { "1" };
                        activeInterfaceWifi = true;
                }
                else
                {
                        mCustomHeaders["Wifi:"] = std::vector<std::string> { "0" };
                        activeInterfaceWifi = false;
                }
        }
        // Add Connection: Keep-Alive custom header - DELIA-26832
        mCustomHeaders["Connection:"] = std::vector<std::string> { "Keep-Alive" };
        pthread_cond_init(&mCondDiscontinuity, NULL);
        pthread_cond_init(&waitforplaystart, NULL);
        pthread_cond_init(&mWaitForDynamicDRMToUpdate,NULL);
        pthread_mutex_init(&mMutexPlaystart, NULL);
        pthread_cond_init(&mWaitForDiscoToComplete,NULL);
        preferredLanguagesList.push_back("en");
 
#ifdef AAMP_HLS_DRM
        memset(&aesCtrAttrDataList, 0, sizeof(aesCtrAttrDataList));
        pthread_mutex_init(&drmParserMutex, NULL);
#endif
        GETCONFIGVALUE_PRIV(eAAMPConfig_HarvestCountLimit,mHarvestCountLimit);
        GETCONFIGVALUE_PRIV(eAAMPConfig_HarvestConfig,mHarvestConfig);
        mAsyncTuneEnabled = ISCONFIGSET_PRIV(eAAMPConfig_AsyncTune);
        }
 
/**
 * @brief PrivateInstanceAAMP Destructor
 */
PrivateInstanceAAMP::~PrivateInstanceAAMP()
{
        StopPausePositionMonitoring("AAMP destroyed");
#ifdef AAMP_CC_ENABLED
    AampCCManager::GetInstance()->Release(mCCId);
    mCCId = 0;
#endif
    pthread_mutex_lock(&gMutex);
        auto iter = std::find_if(std::begin(gActivePrivAAMPs), std::end(gActivePrivAAMPs), [this](const gActivePrivAAMP_t& el)
        {
                return el.pAAMP == this;
        });
        if(iter != gActivePrivAAMPs.end())
        {
                gActivePrivAAMPs.erase(iter);
        }
        pthread_mutex_unlock(&gMutex);
 
        pthread_mutex_lock(&mLock);
 
        SAFE_DELETE(mVideoEnd);
 
        pthread_mutex_unlock(&mLock);
 
        pthread_cond_destroy(&mDownloadsDisabled);
        pthread_cond_destroy(&mWaitForDynamicDRMToUpdate);
        pthread_cond_destroy(&mCondDiscontinuity);
        pthread_cond_destroy(&waitforplaystart);
        pthread_cond_destroy(&mWaitForDiscoToComplete);
        pthread_mutex_destroy(&mMutexPlaystart);
        pthread_mutex_destroy(&mLock);
        pthread_mutex_destroy(&mDynamicDrmUpdateLock);
        pthread_mutex_destroy(&mParallelPlaylistFetchLock);
        pthread_mutex_destroy(&mFragmentCachingLock);
        pthread_mutex_destroy(&mEventLock);
        pthread_mutex_destroy(&mStreamLock);
        pthread_mutex_destroy(&mDiscoCompleteLock);
        pthread_mutexattr_destroy(&mMutexAttr);
#ifdef AAMP_HLS_DRM
        aesCtrAttrDataList.clear();
        pthread_mutex_destroy(&drmParserMutex);
#endif
        SAFE_DELETE(mAampCacheHandler);
 
#if defined(AAMP_MPD_DRM) || defined(AAMP_HLS_DRM)
        SAFE_DELETE(mDRMSessionManager);
#endif
 
        if( ISCONFIGSET_PRIV(eAAMPConfig_EnableCurlStore) )
        {
                for (int i = 0; i < eCURLINSTANCE_MAX; i++)
                {
                        SAFE_DELETE(curlhost[i]);
                }
        }
 
        if ( !(ISCONFIGSET_PRIV(eAAMPConfig_EnableCurlStore)) )
        {
                if(mCurlShared)
                {
                        curl_share_cleanup(mCurlShared);
                        mCurlShared = NULL;
                }
        }
#ifdef IARM_MGR
        IARM_Bus_RemoveEventHandler("NET_SRV_MGR", IARM_BUS_NETWORK_MANAGER_EVENT_INTERFACE_IPADDRESS, getActiveInterfaceEventHandler);
#endif //IARM_MGR
        SAFE_DELETE(mEventManager);
 
        if (HasSidecarData())
        { // has sidecar data
                SAFE_DELETE_ARRAY(mData);
                mData = NULL;
                if (mpStreamAbstractionAAMP)
                        mpStreamAbstractionAAMP->ResetSubtitle();
        }
}
 
/**
 * @brief perform pause of the pipeline and notifications for PauseAt functionality
 */
static gboolean PrivateInstanceAAMP_PausePosition(gpointer ptr)
{
        PrivateInstanceAAMP* aamp = (PrivateInstanceAAMP* )ptr;
        long long pausePositionMilliseconds = aamp->mPausePositionMilliseconds;
        aamp->mPausePositionMilliseconds = AAMP_PAUSE_POSITION_INVALID_POSITION;
 
        if  (pausePositionMilliseconds != AAMP_PAUSE_POSITION_INVALID_POSITION)
        {
                if (!aamp->mStreamSink->Pause(true, false))
                {
                        AAMPLOG_ERR("Pause failed");
                }
                aamp->pipeline_paused = true;
 
                aamp->StopDownloads();
 
                if (aamp->mpStreamAbstractionAAMP)
                {
                        aamp->mpStreamAbstractionAAMP->NotifyPlaybackPaused(true);
                }
 
                bool updateSeekPosition = false;
                if ((aamp->rate > AAMP_NORMAL_PLAY_RATE) || (aamp->rate < AAMP_RATE_PAUSE) ||
                        (!ISCONFIGSET(eAAMPConfig_EnableGstPositionQuery) && !aamp->mbDetached))
                {
                        aamp->seek_pos_seconds = aamp->GetPositionSeconds();
                        aamp->trickStartUTCMS = -1;
                        AAMPLOG_INFO("Updated seek pos %fs", aamp->seek_pos_seconds);
                        updateSeekPosition = true;
                }
                else
                {
                        // (See SetRateInternal)
                        if (!ISCONFIGSET(eAAMPConfig_EnableGstPositionQuery) && !aamp->mbDetached)
                        {
                                aamp->seek_pos_seconds = aamp->GetPositionSeconds();
                                aamp->trickStartUTCMS = -1;
                                AAMPLOG_INFO("Updated seek pos %fs", aamp->seek_pos_seconds);
                                updateSeekPosition = true;
                        }
                }
 
 
                long long positionMs = aamp->GetPositionMilliseconds();
                if (updateSeekPosition)
                {
                        AAMPLOG_WARN("PLAYER[%d] Paused at position %lldms, requested position %lldms, rate %f, seek pos updated to %fs",
                                                aamp->mPlayerId, positionMs, pausePositionMilliseconds, aamp->rate, aamp->seek_pos_seconds);
                }
                else
                {
                        AAMPLOG_WARN("PLAYER[%d] Paused at position %lldms, requested position %lldms, rate %f",
                                                aamp->mPlayerId, positionMs, pausePositionMilliseconds, aamp->rate);
                }
 
                // Notify the client that play has paused
                aamp->NotifySpeedChanged(0, true);
        }
        return G_SOURCE_REMOVE;
}
 
/**
 * @brief the PositionMonitoring thread used for PauseAt functionality
 */
void PrivateInstanceAAMP::RunPausePositionMonitoring(void)
{
        long long localPauseAtMilliseconds = mPausePositionMilliseconds;
        long long posMs = GetPositionMilliseconds();
        int previousPollPeriodMs = 0;
        int previousVodTrickplayFPS = 0;
 
        AAMPLOG_WARN("PLAYER[%d] Pause at position %lldms, current position %lldms, rate %f",
                                mPlayerId, mPausePositionMilliseconds.load(), posMs, rate);
 
        while(localPauseAtMilliseconds != AAMP_PAUSE_POSITION_INVALID_POSITION)
        {
                int pollPeriodMs = AAMP_PAUSE_POSITION_POLL_PERIOD_MS;
                long long trickplayTargetPosMs = localPauseAtMilliseconds;
                bool forcePause = false;
 
                if ((rate == AAMP_RATE_PAUSE) || pipeline_paused)
                {
                        // Shouldn't get here if already paused
                        AAMPLOG_WARN("Already paused, exiting loop");
                        mPausePositionMilliseconds = AAMP_PAUSE_POSITION_INVALID_POSITION;
                        break;
                }
                // If normal speed or slower, i.e. not iframe trick mode
                else if ((rate > AAMP_RATE_PAUSE) && (rate <= AAMP_NORMAL_PLAY_RATE))
                {
                        // If current pos is within a poll period of the target position,
                        // set the sleep time to be the difference, and then perform
                        // the pause.
                        if (posMs >= (localPauseAtMilliseconds - pollPeriodMs))
                        {
                                pollPeriodMs = (localPauseAtMilliseconds - posMs) / rate;
                                forcePause = true;
                                AAMPLOG_INFO("Requested pos %lldms current pos %lldms rate %f, pausing in %dms",
                                                        localPauseAtMilliseconds, posMs, rate, pollPeriodMs);
                        }
                        else
                        {
                                // The first time print WARN diag
                                if (previousPollPeriodMs != pollPeriodMs)
                                {
                                        AAMPLOG_WARN("PLAYER[%d] Polling period %dms, rate %f",
                                                                mPlayerId, pollPeriodMs, rate);
                                        previousPollPeriodMs = pollPeriodMs;
                                }
                                AAMPLOG_INFO("Requested pos %lldms current pos %lldms rate %f, polling period %dms",
                                                        localPauseAtMilliseconds, posMs, rate, pollPeriodMs);
                        }
                }
                else
                {
                        int vodTrickplayFPS = 0;
                        bool config_valid = GETCONFIGVALUE_PRIV(eAAMPConfig_VODTrickPlayFPS,vodTrickplayFPS);
 
                        assert (config_valid && (vodTrickplayFPS != 0));
 
                        // Poll at half the frame period (twice the frame rate)
                        pollPeriodMs = (1000 / vodTrickplayFPS) / 2;
 
                        // If rate > 0, the target position should be earlier than requested pos
                        // If rate < 0, the target position should be later than requested pos
                        trickplayTargetPosMs -= ((rate * 1000) / vodTrickplayFPS);
 
                        if ((previousPollPeriodMs != pollPeriodMs) ||
                                (previousVodTrickplayFPS != vodTrickplayFPS))
                        {
                                AAMPLOG_WARN("PLAYER[%d] Polling period %dms, rate %f, fps %d",
                                                mPlayerId, pollPeriodMs, rate, vodTrickplayFPS);
                                previousPollPeriodMs = pollPeriodMs;
                                previousVodTrickplayFPS = vodTrickplayFPS;
                        }
                        AAMPLOG_INFO("Requested pos %lldms current pos %lldms target pos %lld rate %f, fps %d, polling period %dms",
                                                 localPauseAtMilliseconds, posMs, trickplayTargetPosMs, rate, vodTrickplayFPS, pollPeriodMs);
                }
 
                // The calculation of pollPeriodMs for playback speeds, could result in a negative value
                if (pollPeriodMs > 0)
                {
                        std::unique_lock<std::mutex> lock(mPausePositionMonitorMutex);
                        std::cv_status cvStatus = std::cv_status::no_timeout;
                        std::chrono::time_point<std::chrono::system_clock> waitUntilMs = std::chrono::system_clock::now() +
                                                                                                                                                         std::chrono::milliseconds(pollPeriodMs);
 
                        // Wait until now + pollPeriodMs, unless pauseAt is being cancelled
                        while ((localPauseAtMilliseconds != AAMP_PAUSE_POSITION_INVALID_POSITION) &&
                                   (cvStatus == std::cv_status::no_timeout))
                        {
                                cvStatus = mPausePositionMonitorCV.wait_until(lock, waitUntilMs);
                                localPauseAtMilliseconds = mPausePositionMilliseconds;
                        }
                        if (localPauseAtMilliseconds == AAMP_PAUSE_POSITION_INVALID_POSITION)
                        {
                                break;
                        }
                }
 
                // Only need to get an updated pos if not forcing pause
                if (!forcePause)
                {
                        posMs = GetPositionMilliseconds();
                }
 
                // Check if forcing pause at playback, or exceeded target position for trickplay
                if (forcePause ||
                        ((rate > AAMP_NORMAL_PLAY_RATE) && (posMs >= trickplayTargetPosMs)) ||
                        ((rate < AAMP_RATE_PAUSE) && (posMs <= trickplayTargetPosMs)))
                {
                        (void)ScheduleAsyncTask(PrivateInstanceAAMP_PausePosition, this, "PrivateInstanceAAMP_PausePosition");
                        break;
                }
        }
}
 
/**
 * @brief call the PausePositionMonitoring thread loop
 */
static void *PausePositionMonitor(void *arg)
{
        PrivateInstanceAAMP *aamp = (PrivateInstanceAAMP *)arg;
 
        // Thread name restricted to 16 characters, including null
        if(aamp_pthread_setname(pthread_self(), "aampPauseMon"))
        {
                AAMPLOG_WARN("aamp_pthread_setname failed");
        }
        aamp->RunPausePositionMonitoring();
        return nullptr;
}
 
/**
 * @brief start the PausePositionMonitoring thread used for PauseAt functionality
 */
void PrivateInstanceAAMP::StartPausePositionMonitoring(long long pausePositionMilliseconds)
{
        StopPausePositionMonitoring("Start new pos monitor");
 
        if (pausePositionMilliseconds < 0)
        {
                AAMPLOG_ERR("The position (%lld) must be >= 0", pausePositionMilliseconds);
        }
        else
        {
                mPausePositionMilliseconds = pausePositionMilliseconds;
 
                AAMPLOG_INFO("Start PausePositionMonitoring at position %lld", pausePositionMilliseconds);
 
                if (0 == pthread_create(&mPausePositionMonitoringThreadID, nullptr, &PausePositionMonitor, this))
                {
                        mPausePositionMonitoringThreadStarted = true;
                }
                else
                {
                        AAMPLOG_ERR("Failed to create PausePositionMonitor thread");
                }
        }
}
 
/**
 * @brief stop the PausePositionMonitoring thread used for PauseAt functionality
 */
void PrivateInstanceAAMP::StopPausePositionMonitoring(std::string reason)
{
        if (mPausePositionMonitoringThreadStarted)
        {
                std::unique_lock<std::mutex> lock(mPausePositionMonitorMutex);
 
                if (mPausePositionMilliseconds != AAMP_PAUSE_POSITION_INVALID_POSITION)
                {
                        long long positionMs = GetPositionMilliseconds();
                        AAMPLOG_WARN("PLAYER[%d] Stop position monitoring, reason: '%s', current position %lldms, requested position %lldms, rate %f",
                                                mPlayerId, reason.c_str(), positionMs, mPausePositionMilliseconds.load(), rate);
                        mPausePositionMilliseconds = AAMP_PAUSE_POSITION_INVALID_POSITION;
                        mPausePositionMonitorCV.notify_one();
                }
                lock.unlock();
 
                int rc = pthread_join(mPausePositionMonitoringThreadID, NULL);
                if (rc != 0)
                {
                        AAMPLOG_ERR("***pthread_join PausePositionMonitor returned %d(%s)", rc, strerror(rc));
                }
                else
                {
                        AAMPLOG_INFO("Joined PausePositionMonitor");
                }
                mPausePositionMonitoringThreadStarted = false;
        }
}
 
/**
 * @brief wait for Discontinuity handling complete
 */
void PrivateInstanceAAMP::WaitForDiscontinuityProcessToComplete(void)
{
        pthread_mutex_lock(&mDiscoCompleteLock);
        pthread_cond_wait(&mWaitForDiscoToComplete, &mDiscoCompleteLock);
        pthread_mutex_unlock(&mDiscoCompleteLock);
}
 
/**
 * @brief unblock wait for Discontinuity handling complete
 */
void PrivateInstanceAAMP::UnblockWaitForDiscontinuityProcessToComplete(void)
{
        mIsPeriodChangeMarked = false;
 
        pthread_mutex_lock(&mDiscoCompleteLock);
        pthread_cond_signal(&mWaitForDiscoToComplete);
        pthread_mutex_unlock(&mDiscoCompleteLock);
}
 
/**
 *   @brief GStreamer operation start
 */
void PrivateInstanceAAMP::SyncBegin(void)
{
        pthread_mutex_lock(&mLock);
}
 
/**
 * @brief GStreamer operation end
 *
 */
void PrivateInstanceAAMP::SyncEnd(void)
{
        pthread_mutex_unlock(&mLock);
}
 
/**
 * @brief Report progress event
 */
long long PrivateInstanceAAMP::GetVideoPTS(bool bAddVideoBasePTS)
{
    /*For HLS, tsprocessor.cpp removes the base PTS value and sends to gstreamer.
    **In order to report PTS of video currently being played out, we add the base PTS
    **to video PTS received from gstreamer
    */
    /*For DASH,mVideoBasePTS value will be zero */
    long long videoPTS = -1;
    videoPTS = mStreamSink->GetVideoPTS();
    if(bAddVideoBasePTS)
       videoPTS += mVideoBasePTS;
    AAMPLOG_WARN("Video-PTS=%lld, mVideoBasePTS=%lld Add VideoBase PTS[%d]",videoPTS,mVideoBasePTS,bAddVideoBasePTS);
    return videoPTS;
}
 
/**
 * @brief Report progress event to listeners
 */
void PrivateInstanceAAMP::ReportProgress(bool sync, bool beginningOfStream)
{
        PrivAAMPState state;
        GetState(state);
 
        if (state == eSTATE_SEEKING)
        {
                AAMPLOG_WARN("Progress reporting skipped whilst seeking.");
        }
 
        //Once GST_MESSAGE_EOS is received, AAMP does not want any stray progress to be sent to player. so added the condition state != eSTATE_COMPLETE
        if (mDownloadsEnabled && (state != eSTATE_IDLE) && (state != eSTATE_RELEASED) && (state != eSTATE_COMPLETE) && (state != eSTATE_SEEKING))
        {
                ReportAdProgress(sync);
 
                // set position to 0 if the rewind operation has reached Beginning Of Stream
                double position = beginningOfStream? 0: GetPositionMilliseconds();
                double duration = durationSeconds * 1000.0;
                float speed = pipeline_paused ? 0 : rate;
                double start = -1;
                double end = -1;
                long long videoPTS = -1;
                double bufferedDuration = 0.0;
                bool bProcessEvent = true;
 
                // If tsb is not available for linear send -1  for start and end
                // so that xre detect this as tsbless playabck
                // Override above logic if mEnableSeekableRange is set, used by third-party apps
                if (!ISCONFIGSET_PRIV(eAAMPConfig_EnableSeekRange) && (mContentType == ContentType_LINEAR && !mTSBEnabled))
                {
                        start = -1;
                        end = -1;
                }
                else
                {       //DELIA-49735 - Report Progress report position based on Availability Start Time
                        start = (culledSeconds*1000.0);
                        if(ISCONFIGSET_PRIV(eAAMPConfig_UseAbsoluteTimeline) && (mProgressReportOffset >= 0) && IsLiveStream() && !IsUninterruptedTSB())
                        {
                                end = (mAbsoluteEndPosition * 1000);
                        }
                        else
                        {
                                end = start + duration;
                        }
 
                        if (position > end)
                        { // clamp end
                                //AAMPLOG_WARN("aamp clamp end");
                                position = end;
                        }
                        else if (position < start)
                        { // clamp start
                                //AAMPLOG_WARN("aamp clamp start");
                                position = start;
                        }
                }
 
                if(ISCONFIGSET_PRIV(eAAMPConfig_ReportVideoPTS))
                {
                                /*For HLS, tsprocessor.cpp removes the base PTS value and sends to gstreamer.
                                **In order to report PTS of video currently being played out, we add the base PTS
                                **to video PTS received from gstreamer
                                */
                                /*For DASH,mVideoBasePTS value will be zero */
                                videoPTS = mStreamSink->GetVideoPTS() + mVideoBasePTS;
                }
 
                pthread_mutex_lock(&mStreamLock);
                if (mpStreamAbstractionAAMP)
                {
                        bufferedDuration = mpStreamAbstractionAAMP->GetBufferedVideoDurationSec() * 1000.0;
                }
                pthread_mutex_unlock(&mStreamLock);
 
                if ((mReportProgressPosn == position) && !pipeline_paused && beginningOfStream != true)
                {
                        // Avoid sending the progress event, if the previous position and the current position is same when pipeline is in playing state.
                        // Addded exception if it's beginning of stream to prevent JSPP not loading previous AD while rewind
                        bProcessEvent = false;
                }
 
                /*LLAMA-7142 & LLAMA-7124
                **mNewSeekInfo is:
                **  -Used by PlayerInstanceAAMP::SetRateInternal() to calculate seek position.
                **  -Included for consistency with previous code but isn't directly related to reporting.
                **  -A good candidate for future refactoring*/
                mNewSeekInfo.Update(position, seek_pos_seconds);
 
                double reportFormatPosition = position;
                if(ISCONFIGSET_PRIV(eAAMPConfig_UseAbsoluteTimeline) && ISCONFIGSET_PRIV(eAAMPConfig_InterruptHandling) && mTSBEnabled)
                {
                        start -= (mProgressReportOffset * 1000);
                        reportFormatPosition -= (mProgressReportOffset * 1000);
                        end -= (mProgressReportOffset * 1000);
                }
 
                ProgressEventPtr evt = std::make_shared<ProgressEvent>(duration, reportFormatPosition, start, end, speed, videoPTS, bufferedDuration, seiTimecode.c_str());
 
                if (trickStartUTCMS >= 0 && (bProcessEvent || mFirstProgress))
                {
                        if (mFirstProgress)
                        {
                                mFirstProgress = false;
                                AAMPLOG_WARN("Send first progress event with position %ld", (long)(reportFormatPosition / 1000));
                        }
 
                        if (ISCONFIGSET_PRIV(eAAMPConfig_ProgressLogging))
                        {
                                static int tick;
                                if ((tick++ % 4) == 0)
                                {
                                        AAMPLOG_WARN("aamp pos: [%ld..%ld..%ld..%lld..%ld..%s]",
                                                (long)(start / 1000),
                                                (long)(reportFormatPosition / 1000),
                                                (long)(end / 1000),
                                                (long long) videoPTS,
                                                (long)(bufferedDuration / 1000),
                                                seiTimecode.c_str() );
                                }
                        }
 
                        if (sync)
                        {
                                mEventManager->SendEvent(evt,AAMP_EVENT_SYNC_MODE);
                        }
                        else
                        {
                                mEventManager->SendEvent(evt);
                        }
 
                        mReportProgressPosn = position;
                }
        }
}
 
/**
 *   @brief Report Ad progress event to listeners
 *          Sending Ad progress percentage to JSPP
 */
void PrivateInstanceAAMP::ReportAdProgress(bool sync)
{
        if (mDownloadsEnabled && !mAdProgressId.empty())
        {
                long long curTime = NOW_STEADY_TS_MS;
                if (!pipeline_paused)
                {
                        //Update the percentage only if the pipeline is in playing.
                        mAdCurOffset += (uint32_t)(curTime - mAdPrevProgressTime);
                        if(mAdCurOffset > mAdDuration) mAdCurOffset = mAdDuration;
                }
                mAdPrevProgressTime = curTime;
 
                AdPlacementEventPtr evt = std::make_shared<AdPlacementEvent>(AAMP_EVENT_AD_PLACEMENT_PROGRESS, mAdProgressId, (uint32_t)(mAdCurOffset * 100) / mAdDuration);
                if(sync)
                {
                        mEventManager->SendEvent(evt,AAMP_EVENT_SYNC_MODE);
                }
                else
                {
                        mEventManager->SendEvent(evt);
                }
        }
}
 
/**
 * @brief Update playlist duration
 */
void PrivateInstanceAAMP::UpdateDuration(double seconds)
{
        AAMPLOG_INFO("aamp_UpdateDuration(%f)", seconds);
        durationSeconds = seconds;
}
 
/**
 * @brief Update playlist culling
 */
void PrivateInstanceAAMP::UpdateCullingState(double culledSecs)
{
        if (culledSecs == 0)
        {
                return;
        }
 
        if((!this->culledSeconds) && culledSecs)
        {
                AAMPLOG_WARN("PrivateInstanceAAMP: culling started, first value %f", culledSecs);
        }
 
        this->culledSeconds += culledSecs;
        long long limitMs = (long long) std::round(this->culledSeconds * 1000.0);
 
        for (auto iter = timedMetadata.begin(); iter != timedMetadata.end(); )
        {
                // If the timed metadata has expired due to playlist refresh, remove it from local cache
                // For X-CONTENT-IDENTIFIER, -X-IDENTITY-ADS, X-MESSAGE_REF in DASH which has _timeMS as 0
                if (iter->_timeMS != 0 && iter->_timeMS < limitMs)
                {
                        //AAMPLOG_WARN("ERASE(limit:%lld) aamp_ReportTimedMetadata(%lld, '%s', '%s', nb)", limitMs,iter->_timeMS, iter->_name.c_str(), iter->_content.c_str());
                        //AAMPLOG_WARN("ERASE(limit:%lld) aamp_ReportTimedMetadata(%lld)", limitMs,iter->_timeMS);
                        iter = timedMetadata.erase(iter);
                }
                else
                {
                        iter++;
                }
        }
 
        // Remove contentGaps vector based on culling.
        if(ISCONFIGSET_PRIV(eAAMPConfig_InterruptHandling))
        {
                for (auto iter = contentGaps.begin(); iter != contentGaps.end();)
                {
                        if (iter->_timeMS != 0 && iter->_timeMS < limitMs)
                        {
                                iter = contentGaps.erase(iter);
                        }
                        else
                        {
                                iter++;
                        }
                }
        }
 
        // Check if we are paused and culled past paused playback position
        // AAMP internally caches fragments in sw and gst buffer, so we should be good here
        // Pipeline will be in Paused state when Lightning trickplay is done. During this state XRE will send the resume position to exit pause state .
        // Issue observed when culled position reaches the paused position during lightning trickplay and player resumes the playback with paused position as playback position ignoring XRE shown position.
        // Fix checks if the player is put into paused state with lighting mode(by checking last stored rate). 
        // In this state player will not come out of Paused state, even if the culled position reaches paused position.
        // The rate check is a special case for a specific player, if this is contradicting to other players, we will have to add a config to enable/disable
        if (pipeline_paused && mpStreamAbstractionAAMP && (abs(rate) != AAMP_RATE_TRICKPLAY_MAX))
        {
                double position = GetPositionSeconds();
                double minPlaylistPositionToResume = (position < maxRefreshPlaylistIntervalSecs) ? position : (position - maxRefreshPlaylistIntervalSecs);
                if (this->culledSeconds >= position)
                {
                        if (mPausedBehavior <= ePAUSED_BEHAVIOR_LIVE_IMMEDIATE 
                                        && this->culledSeconds != culledSecs /* Don't auto resume for first culled on PAUSED */)
                        {
                                // Immediate play from paused state, Execute player resume.
                                // Live immediate - Play from live position
                                // Autoplay immediate - Play from start of live window
                                if(ePAUSED_BEHAVIOR_LIVE_IMMEDIATE == mPausedBehavior)
                                {
                                        // Enable this flag to perform seek to live.
                                        mSeekFromPausedState = true;
                                }
                                AAMPLOG_WARN("Resume playback since playlist start position(%f) has moved past paused position(%f) ", this->culledSeconds, position);
                                if (!mAutoResumeTaskPending)
                                {
                                        mAutoResumeTaskPending = true;
                                        mAutoResumeTaskId = ScheduleAsyncTask(PrivateInstanceAAMP_Resume, (void *)this, "PrivateInstanceAAMP_Resume");
                                }
                                else
                                {
                                        AAMPLOG_WARN("Auto resume playback task already exists, avoid creating duplicates for now!");
                                }
                        }
                        else if(mPausedBehavior >= ePAUSED_BEHAVIOR_AUTOPLAY_DEFER)
                        {
                                // Wait for play() call to resume, enable mSeekFromPausedState for reconfigure.
                                // Live differ - Play from live position
                                // Autoplay differ -Play from eldest part (start of live window)
                                mSeekFromPausedState = true;
                                if(ePAUSED_BEHAVIOR_LIVE_DEFER == mPausedBehavior)
                                {
                                        mJumpToLiveFromPause = true;
                                }
                        }
                }
                else if (this->culledSeconds >= minPlaylistPositionToResume)
                {
                        // Here there is a chance that paused position will be culled after next refresh playlist
                        // AAMP internally caches fragments in sw bufffer after paused position, so we are at less risk
                        // Make sure that culledSecs is within the limits of maxRefreshPlaylistIntervalSecs
                        // This check helps us to avoid initial culling done by FOG after channel tune
 
                        if (culledSecs <= maxRefreshPlaylistIntervalSecs)
                        {
                                if (mPausedBehavior <= ePAUSED_BEHAVIOR_LIVE_IMMEDIATE)
                                {
                                        if(ePAUSED_BEHAVIOR_LIVE_IMMEDIATE == mPausedBehavior)
                                        {
                                                mSeekFromPausedState = true;
                                        }
                                        AAMPLOG_WARN("Resume playback since start position(%f) moved very close to minimum resume position(%f) ", this->culledSeconds, minPlaylistPositionToResume);
                                        if (!mAutoResumeTaskPending)
                                        {
                                                mAutoResumeTaskPending = true;
                                                mAutoResumeTaskId = ScheduleAsyncTask(PrivateInstanceAAMP_Resume, (void *)this, "PrivateInstanceAAMP_Resume");
                                        }
                                        else
                                        {
                                                AAMPLOG_WARN("Auto resume playback task already exists, avoid creating duplicates for now!");
                                        }
                                }
                                else if(mPausedBehavior >= ePAUSED_BEHAVIOR_AUTOPLAY_DEFER)
                                {
                                        mSeekFromPausedState = true;
                                        if(ePAUSED_BEHAVIOR_LIVE_DEFER == mPausedBehavior)
                                        {
                                                mJumpToLiveFromPause = true;
                                        }
                                }
                        }
                        else
                        {
                                AAMPLOG_WARN("Auto resume playback task already exists, avoid creating duplicates for now!");
                        }
                }
        }
}
 
/**
 * @brief Add listener to aamp events
 */
void PrivateInstanceAAMP::AddEventListener(AAMPEventType eventType, EventListener* eventListener)
{
        mEventManager->AddEventListener(eventType,eventListener);
}
 
 
/**
 * @brief Deregister event lister, Remove listener to aamp events
 */
void PrivateInstanceAAMP::RemoveEventListener(AAMPEventType eventType, EventListener* eventListener)
{
        mEventManager->RemoveEventListener(eventType,eventListener);
}
 
/**
 * @brief IsEventListenerAvailable Check if Event is registered
 */
bool PrivateInstanceAAMP::IsEventListenerAvailable(AAMPEventType eventType)
{
        return mEventManager->IsEventListenerAvailable(eventType);
}
 
/**
 * @brief Handles DRM errors and sends events to application if required.
 */
void PrivateInstanceAAMP::SendDrmErrorEvent(DrmMetaDataEventPtr event, bool isRetryEnabled)
{
        if (event)
        {
                AAMPTuneFailure tuneFailure = event->getFailure();
                long error_code = event->getResponseCode();
                bool isSecClientError = event->getSecclientError();
                long secManagerReasonCode = event->getSecManagerReasonCode();
                 
                if(AAMP_TUNE_FAILED_TO_GET_ACCESS_TOKEN == tuneFailure || AAMP_TUNE_LICENCE_REQUEST_FAILED == tuneFailure)
                {
                        char description[128] = {};
                        //When using secmanager the erro_code would not be less than 100
                        if(AAMP_TUNE_LICENCE_REQUEST_FAILED == tuneFailure && (error_code < 100 || ISCONFIGSET_PRIV(eAAMPConfig_UseSecManager)))
                        {
                                
                                if (isSecClientError)
                                {
                                        if(ISCONFIGSET_PRIV(eAAMPConfig_UseSecManager))
                                        {
                                                snprintf(description, MAX_ERROR_DESCRIPTION_LENGTH - 1, "%s : SecManager Error Code %ld:%ld", tuneFailureMap[tuneFailure].description,error_code, secManagerReasonCode);
                                        }
                                        else
                                        {
                                                snprintf(description, MAX_ERROR_DESCRIPTION_LENGTH - 1, "%s : Secclient Error Code %ld", tuneFailureMap[tuneFailure].description, error_code);
                                        }
                                }
                                else
                                {
                                        snprintf(description, MAX_ERROR_DESCRIPTION_LENGTH - 1, "%s : Curl Error Code %ld", tuneFailureMap[tuneFailure].description, error_code);
                                }
                        }
                        else if (AAMP_TUNE_FAILED_TO_GET_ACCESS_TOKEN == tuneFailure && eAUTHTOKEN_TOKEN_PARSE_ERROR == (AuthTokenErrors)error_code)
                        {
                                snprintf(description, MAX_ERROR_DESCRIPTION_LENGTH - 1, "%s : Access Token Parse Error", tuneFailureMap[tuneFailure].description);
                        }
                        else if(AAMP_TUNE_FAILED_TO_GET_ACCESS_TOKEN == tuneFailure && eAUTHTOKEN_INVALID_STATUS_CODE == (AuthTokenErrors)error_code)
                        {
                                snprintf(description, MAX_ERROR_DESCRIPTION_LENGTH - 1, "%s : Invalid status code", tuneFailureMap[tuneFailure].description);
                        }
                        else
                        {
                                snprintf(description, MAX_ERROR_DESCRIPTION_LENGTH - 1, "%s : Http Error Code %ld", tuneFailureMap[tuneFailure].description, error_code);
                        }
                        SendErrorEvent(tuneFailure, description, isRetryEnabled, event->getSecManagerClassCode(),event->getSecManagerReasonCode(), event->getBusinessStatus());
                }
                else if(tuneFailure >= 0 && tuneFailure < AAMP_TUNE_FAILURE_UNKNOWN)
                {
                        SendErrorEvent(tuneFailure, NULL, isRetryEnabled, event->getSecManagerClassCode(),event->getSecManagerReasonCode(), event->getBusinessStatus());
                }
                else
                {
                        AAMPLOG_WARN("Received unknown error event %d", tuneFailure);
                        SendErrorEvent(AAMP_TUNE_FAILURE_UNKNOWN);
                }
        }
}
 
/**
 * @brief Handles download errors and sends events to application if required.
 */
void PrivateInstanceAAMP::SendDownloadErrorEvent(AAMPTuneFailure tuneFailure, long error_code)
{
        AAMPTuneFailure actualFailure = tuneFailure;
        bool retryStatus = true;
 
        if(tuneFailure >= 0 && tuneFailure < AAMP_TUNE_FAILURE_UNKNOWN)
        {
                char description[MAX_DESCRIPTION_SIZE] = {};
                if (((error_code >= PARTIAL_FILE_CONNECTIVITY_AAMP) && (error_code <= PARTIAL_FILE_START_STALL_TIMEOUT_AAMP)) || error_code == CURLE_OPERATION_TIMEDOUT)
                {
                        switch(error_code)
                        {
                                case PARTIAL_FILE_DOWNLOAD_TIME_EXPIRED_AAMP:
                                                error_code = CURLE_PARTIAL_FILE;
                                case CURLE_OPERATION_TIMEDOUT:
                                                snprintf(description,MAX_DESCRIPTION_SIZE, "%s : Curl Error Code %ld, Download time expired", tuneFailureMap[tuneFailure].description, error_code);
                                                break;
                                case PARTIAL_FILE_START_STALL_TIMEOUT_AAMP:
                                                snprintf(description,MAX_DESCRIPTION_SIZE, "%s : Curl Error Code %d, Start/Stall timeout", tuneFailureMap[tuneFailure].description, CURLE_PARTIAL_FILE);
                                                break;
                                case OPERATION_TIMEOUT_CONNECTIVITY_AAMP:
                                                snprintf(description,MAX_DESCRIPTION_SIZE, "%s : Curl Error Code %d, Connectivity failure", tuneFailureMap[tuneFailure].description, CURLE_OPERATION_TIMEDOUT);
                                                break;
                                case PARTIAL_FILE_CONNECTIVITY_AAMP:
                                                snprintf(description,MAX_DESCRIPTION_SIZE, "%s : Curl Error Code %d, Connectivity failure", tuneFailureMap[tuneFailure].description, CURLE_PARTIAL_FILE);
                                                break;
                        }
                }
                else if(error_code < 100)
                {
                        snprintf(description,MAX_DESCRIPTION_SIZE, "%s : Curl Error Code %ld", tuneFailureMap[tuneFailure].description, error_code);  //CID:86441 - DC>STRING_BUFFER
                }
                else
                {
                        snprintf(description,MAX_DESCRIPTION_SIZE, "%s : Http Error Code %ld", tuneFailureMap[tuneFailure].description, error_code);
                        if (error_code == 404)
                        {
                                actualFailure = AAMP_TUNE_CONTENT_NOT_FOUND;
                        }
                        else if (error_code == 421)     // http 421 - Fog power saving mode failure
                        {
                                 retryStatus = false;
                        }
                }
                if( IsTSBSupported() )
                {
                        strcat(description, "(FOG)");
                }
 
                SendErrorEvent(actualFailure, description, retryStatus);
        }
        else
        {
                AAMPLOG_WARN("Received unknown error event %d", tuneFailure);
                SendErrorEvent(AAMP_TUNE_FAILURE_UNKNOWN);
        }
}
 
/**
 * @brief Sends Anomaly Error/warning messages
 */
void PrivateInstanceAAMP::SendAnomalyEvent(AAMPAnomalyMessageType type, const char* format, ...)
{
        if(NULL != format && mEventManager->IsEventListenerAvailable(AAMP_EVENT_REPORT_ANOMALY))
        {
                va_list args;
                va_start(args, format);
 
                char msgData[MAX_ANOMALY_BUFF_SIZE];
 
                msgData[(MAX_ANOMALY_BUFF_SIZE-1)] = 0;
                vsnprintf(msgData, (MAX_ANOMALY_BUFF_SIZE-1), format, args);
 
                AnomalyReportEventPtr e = std::make_shared<AnomalyReportEvent>(type, msgData);
 
                AAMPLOG_INFO("Anomaly evt:%d msg:%s", e->getSeverity(), msgData);
                SendEvent(e,AAMP_EVENT_ASYNC_MODE);
                va_end(args);  //CID:82734 - VARAGAS
        }
}
 
 
/**
 *   @brief  Update playlist refresh interval
 */
void PrivateInstanceAAMP::UpdateRefreshPlaylistInterval(float maxIntervalSecs)
{
        AAMPLOG_INFO("maxRefreshPlaylistIntervalSecs (%f)", maxIntervalSecs);
        maxRefreshPlaylistIntervalSecs = maxIntervalSecs;
}
 
/**
 * @brief Sends UnderFlow Event messages
 */
void PrivateInstanceAAMP::SendBufferChangeEvent(bool bufferingStopped)
{
        // Buffer Change event indicate buffer availability 
        // Buffering stop notification need to be inverted to indicate if buffer available or not 
        // BufferChangeEvent with False = Underflow / non-availability of buffer to play 
        // BufferChangeEvent with True  = Availability of buffer to play 
        BufferingChangedEventPtr e = std::make_shared<BufferingChangedEvent>(!bufferingStopped); 
 
        SetBufUnderFlowStatus(bufferingStopped);
        AAMPLOG_INFO("PrivateInstanceAAMP: Sending Buffer Change event status (Buffering): %s", (e->buffering() ? "End": "Start"));
        SendEvent(e,AAMP_EVENT_ASYNC_MODE);
}
 
/**
 * @brief To change the the gstreamer pipeline to pause/play 
 */
bool PrivateInstanceAAMP::PausePipeline(bool pause, bool forceStopGstreamerPreBuffering)
{
        if (true != mStreamSink->Pause(pause, forceStopGstreamerPreBuffering))
        {
                return false;
        }
        pipeline_paused = pause;
        return true;
}
 
/**
 * @brief Handles errors and sends events to application if required.
 * For download failures, use SendDownloadErrorEvent instead.
 */
void PrivateInstanceAAMP::SendErrorEvent(AAMPTuneFailure tuneFailure, const char * description, bool isRetryEnabled, int32_t secManagerClassCode, int32_t secManagerReasonCode, int32_t secClientBusinessStatus)
{
        bool sendErrorEvent = false;
        pthread_mutex_lock(&mLock);
        if(mState != eSTATE_ERROR)
        {
                if(IsTSBSupported() && mState <= eSTATE_PREPARED)
                {
                        // Send a TSB delete request when player is not tuned successfully.
                        // If player is once tuned, retune happens with same content and player can reuse same TSB.
                        std::string remoteUrl = "127.0.0.1:9080/tsb";
                        long http_error = -1;
                        ProcessCustomCurlRequest(remoteUrl, NULL, &http_error, eCURL_DELETE);
                }
                sendErrorEvent = true;
                mState = eSTATE_ERROR;
        }
        pthread_mutex_unlock(&mLock);
        if (sendErrorEvent)
        {
                int code;
                const char *errorDescription = NULL;
                DisableDownloads();
                if(tuneFailure >= 0 && tuneFailure < AAMP_TUNE_FAILURE_UNKNOWN)
                {
                        if (tuneFailure == AAMP_TUNE_PLAYBACK_STALLED)
                        { // allow config override for stall detection error code
                                GETCONFIGVALUE_PRIV(eAAMPConfig_StallErrorCode,code);
                        }
                        else
                        {
                                code = tuneFailureMap[tuneFailure].code;
                        }
                        if(description)
                        {
                                errorDescription = description;
                        }
                        else
                        {
                                errorDescription = tuneFailureMap[tuneFailure].description;
                        }
                }
                else
                {
                        code = tuneFailureMap[AAMP_TUNE_FAILURE_UNKNOWN].code;
                        errorDescription = tuneFailureMap[AAMP_TUNE_FAILURE_UNKNOWN].description;
                }
 
                MediaErrorEventPtr e = std::make_shared<MediaErrorEvent>(tuneFailure, code, errorDescription, isRetryEnabled, secManagerClassCode, secManagerReasonCode, secClientBusinessStatus);
                SendAnomalyEvent(ANOMALY_ERROR, "Error[%d]:%s", tuneFailure, e->getDescription().c_str());
                if (!mAppName.empty())
                {
                        AAMPLOG_ERR("%s PLAYER[%d] APP: %s Sending error %s",(mbPlayEnabled?STRFGPLAYER:STRBGPLAYER), mPlayerId, mAppName.c_str(), e->getDescription().c_str());
                }
                else
                {
                        AAMPLOG_ERR("%s PLAYER[%d] Sending error %s",(mbPlayEnabled?STRFGPLAYER:STRBGPLAYER), mPlayerId, e->getDescription().c_str());
                }
 
                if (rate != AAMP_NORMAL_PLAY_RATE)
                {
                        NotifySpeedChanged(AAMP_NORMAL_PLAY_RATE, false); // During trick play if the playback failed, send speed change event to XRE to reset its current speed rate.
                }
 
                SendEvent(e,AAMP_EVENT_ASYNC_MODE);
                mFailureReason=tuneFailureMap[tuneFailure].description;
        }
        else
        {
                AAMPLOG_WARN("PrivateInstanceAAMP: Ignore error %d[%s]", (int)tuneFailure, description);
        }
}
 
/**
 * @brief Send event to listeners
 */
void PrivateInstanceAAMP::SendEvent(AAMPEventPtr eventData, AAMPEventMode eventMode)
{
        mEventManager->SendEvent(eventData, eventMode);
}
 
/**
 * @brief Notify bit rate change event to listeners
 */
void PrivateInstanceAAMP::NotifyBitRateChangeEvent(int bitrate, BitrateChangeReason reason, int width, int height, double frameRate, double position, bool GetBWIndex, VideoScanType scantype, int aspectRatioWidth, int aspectRatioHeight)
{
        if(mEventManager->IsEventListenerAvailable(AAMP_EVENT_BITRATE_CHANGED))
        {
                AAMPEventPtr event = std::make_shared<BitrateChangeEvent>((int)aamp_GetCurrentTimeMS(), bitrate, BITRATEREASON2STRING(reason), width, height, frameRate, position, mProfileCappedStatus, mDisplayWidth, mDisplayHeight, scantype, aspectRatioWidth, aspectRatioHeight);
 
                /* START: Added As Part of DELIA-28363 and DELIA-28247 */
                if(GetBWIndex)
                {
                        AAMPLOG_WARN("NotifyBitRateChangeEvent :: bitrate:%d desc:%s width:%d height:%d fps:%f position:%f IndexFromTopProfile: %d%s profileCap:%d tvWidth:%d tvHeight:%d, scantype:%d, aspectRatioW:%d, aspectRatioH:%d",
                                bitrate, BITRATEREASON2STRING(reason), width, height, frameRate, position, mpStreamAbstractionAAMP->GetBWIndex(bitrate), (IsTSBSupported()? ", fog": " "), mProfileCappedStatus, mDisplayWidth, mDisplayHeight, scantype, aspectRatioWidth, aspectRatioHeight);
                }
                else
                {
                        AAMPLOG_WARN("NotifyBitRateChangeEvent :: bitrate:%d desc:%s width:%d height:%d fps:%f position:%f %s profileCap:%d tvWidth:%d tvHeight:%d, scantype:%d, aspectRatioW:%d, aspectRatioH:%d",
                                bitrate, BITRATEREASON2STRING(reason), width, height, frameRate, position, (IsTSBSupported()? ", fog": " "), mProfileCappedStatus, mDisplayWidth, mDisplayHeight, scantype, aspectRatioWidth, aspectRatioHeight);
                }
                /* END: Added As Part of DELIA-28363 and DELIA-28247 */
 
                SendEvent(event,AAMP_EVENT_ASYNC_MODE);
        }
        else
        {
                /* START: Added As Part of DELIA-28363 and DELIA-28247 */
                if(GetBWIndex)
                {
                        AAMPLOG_WARN("NotifyBitRateChangeEvent ::NO LISTENERS bitrate:%d desc:%s width:%d height:%d, fps:%f position:%f IndexFromTopProfile: %d%s profileCap:%d tvWidth:%d tvHeight:%d, scantype:%d, aspectRatioW:%d, aspectRatioH:%d",
                                bitrate, BITRATEREASON2STRING(reason), width, height, frameRate, position, mpStreamAbstractionAAMP->GetBWIndex(bitrate), (IsTSBSupported()? ", fog": " "), mProfileCappedStatus, mDisplayWidth, mDisplayHeight, scantype, aspectRatioWidth, aspectRatioHeight);
                }
                else
                {
                        AAMPLOG_WARN("NotifyBitRateChangeEvent ::NO LISTENERS bitrate:%d desc:%s width:%d height:%d fps:%f position:%f %s profileCap:%d tvWidth:%d tvHeight:%d, scantype:%d, aspectRatioW:%d, aspectRatioH:%d",
                                bitrate, BITRATEREASON2STRING(reason), width, height, frameRate, position, (IsTSBSupported()? ", fog": " "), mProfileCappedStatus, mDisplayWidth, mDisplayHeight, scantype, aspectRatioWidth, aspectRatioHeight);
                }
                /* END: Added As Part of DELIA-28363 and DELIA-28247 */
        }
 
        AAMPLOG_WARN("BitrateChanged:%d", reason);
}
 
 
/**
 * @brief Notify speed change event to listeners
 */
void PrivateInstanceAAMP::NotifySpeedChanged(float rate, bool changeState)
{
        if (changeState)
        {
                if (rate == 0)
                {
                        SetState(eSTATE_PAUSED);
                        if (HasSidecarData())
                        { // has sidecar data
                                if (mpStreamAbstractionAAMP)
                                        mpStreamAbstractionAAMP->MuteSubtitleOnPause();
                        }
                }
                else if (rate == AAMP_NORMAL_PLAY_RATE)
                {
                        if (mTrickplayInProgress)
                        {
                                mTrickplayInProgress = false;
                        }
                        else
                        {
                                if (HasSidecarData())
                                { // has sidecar data
                                        if (mpStreamAbstractionAAMP)
                                                mpStreamAbstractionAAMP->ResumeSubtitleOnPlay(subtitles_muted, mData);
                                }
                        }
                        SetState(eSTATE_PLAYING);
                }
                else
                {
                        mTrickplayInProgress = true;
                        if (HasSidecarData())
                        { // has sidecar data
                                if (mpStreamAbstractionAAMP)
                                        mpStreamAbstractionAAMP->MuteSidecarSubtitles(true);
                        }
                }
        }
 
#ifdef AAMP_CC_ENABLED
        if (ISCONFIGSET_PRIV(eAAMPConfig_NativeCCRendering))
        {
                if (rate == AAMP_NORMAL_PLAY_RATE)
                {
                        AampCCManager::GetInstance()->SetTrickplayStatus(false);
                }
                else
                {
                        AampCCManager::GetInstance()->SetTrickplayStatus(true);
                }
        }
#endif
        //Hack For DELIA-51318 convert the incoming rates into acceptable rates
        if(ISCONFIGSET_PRIV(eAAMPConfig_RepairIframes))
        {
                AAMPLOG_WARN("mRepairIframes is set, sending pseudo rate %f for the actual rate %f", getPseudoTrickplayRate(rate), rate);
                SendEvent(std::make_shared<SpeedChangedEvent>(getPseudoTrickplayRate(rate)),AAMP_EVENT_ASYNC_MODE);
        }
        else
        {
                SendEvent(std::make_shared<SpeedChangedEvent>(rate),AAMP_EVENT_ASYNC_MODE);
        }
#ifdef USE_SECMANAGER
        if(ISCONFIGSET_PRIV(eAAMPConfig_UseSecManager))
        {
                mDRMSessionManager->setPlaybackSpeedState(rate,seek_pos_seconds);
        }
#endif
}
 
/**
 * @brief Send DRM metadata event
 */
void PrivateInstanceAAMP::SendDRMMetaData(DrmMetaDataEventPtr e)
{
        SendEvent(e,AAMP_EVENT_ASYNC_MODE);
        AAMPLOG_WARN("SendDRMMetaData name = %s value = %x", e->getAccessStatus().c_str(), e->getAccessStatusValue());
}
 
/**
 *   @brief Check if discontinuity processing is pending 
 */
bool PrivateInstanceAAMP::IsDiscontinuityProcessPending()
{
        bool vidDiscontinuity = (mVideoFormat != FORMAT_INVALID && mProcessingDiscontinuity[eMEDIATYPE_VIDEO]);
        bool audDiscontinuity = (mAudioFormat != FORMAT_INVALID && mProcessingDiscontinuity[eMEDIATYPE_AUDIO]);
        return (vidDiscontinuity || audDiscontinuity);
}
 
/**
 *   @brief Process pending discontinuity and continue playback of stream after discontinuity
 *
 *   @return true if pending discontinuity was processed successful, false if interrupted
 */
bool PrivateInstanceAAMP::ProcessPendingDiscontinuity()
{
        bool ret = true;
        SyncBegin();
        if (mDiscontinuityTuneOperationInProgress)
        {
                SyncEnd();
                AAMPLOG_WARN("PrivateInstanceAAMP: Discontinuity Tune Operation already in progress");
                UnblockWaitForDiscontinuityProcessToComplete();
                return ret; // true so that PrivateInstanceAAMP_ProcessDiscontinuity can cleanup properly
        }
        SyncEnd();
        
        if (!(DiscontinuitySeenInAllTracks()))
        {
                AAMPLOG_ERR("PrivateInstanceAAMP: Discontinuity status of video - (%d), audio - (%d) and aux - (%d)", mProcessingDiscontinuity[eMEDIATYPE_VIDEO], mProcessingDiscontinuity[eMEDIATYPE_AUDIO], mProcessingDiscontinuity[eMEDIATYPE_AUX_AUDIO]);
                UnblockWaitForDiscontinuityProcessToComplete();
                return ret; // true so that PrivateInstanceAAMP_ProcessDiscontinuity can cleanup properly
        }
 
        SyncBegin();
        mDiscontinuityTuneOperationInProgress = true;
        SyncEnd();
        
        if (DiscontinuitySeenInAllTracks())
        {
                bool continueDiscontProcessing = true;
                AAMPLOG_WARN("PrivateInstanceAAMP: mProcessingDiscontinuity set");
                // DELIA-46559, there is a chance that synchronous progress event sent will take some time to return back to AAMP
                // This can lead to discontinuity stall detection kicking in. So once we start discontinuity processing, reset the flags
                ResetDiscontinuityInTracks();
                ResetTrackDiscontinuityIgnoredStatus();
                lastUnderFlowTimeMs[eMEDIATYPE_VIDEO] = 0;
                lastUnderFlowTimeMs[eMEDIATYPE_AUDIO] = 0;
                lastUnderFlowTimeMs[eMEDIATYPE_AUX_AUDIO] = 0;
 
                {
                        double newPosition = GetPositionSeconds();
                        double injectedPosition = seek_pos_seconds + mpStreamAbstractionAAMP->GetLastInjectedFragmentPosition();
                        double startTimeofFirstSample = 0;
                        AAMPLOG_WARN("PrivateInstanceAAMP: last injected position:%f position calcualted: %f", injectedPosition, newPosition);
 
                        // Reset with injected position from StreamAbstractionAAMP. This ensures that any drift in
                        // GStreamer position reporting is taken care of.
                        // BCOM-4765: Set seek_pos_seconds to injected position only in case of westerossink. In cases with
                        // brcmvideodecoder, we have noticed a drift of 500ms for HLS-TS assets (due to PTS restamping
                        if (injectedPosition != 0 && (fabs(injectedPosition - newPosition) < 5.0) && ISCONFIGSET_PRIV(eAAMPConfig_UseWesterosSink))
                        {
                                seek_pos_seconds = injectedPosition;
                        }
                        else
                        {
                                seek_pos_seconds = newPosition;
                        }
 
                        if(!IsUninterruptedTSB() && (mMediaFormat == eMEDIAFORMAT_DASH))
                        {
                                startTimeofFirstSample = mpStreamAbstractionAAMP->GetStartTimeOfFirstPTS() / 1000;
                                if(startTimeofFirstSample > 0)
                                {
                                        AAMPLOG_WARN("PrivateInstanceAAMP: Position is updated to start time of discontinuity : %lf", startTimeofFirstSample);
                                        seek_pos_seconds = startTimeofFirstSample;
                                }
                        }
                        AAMPLOG_WARN("PrivateInstanceAAMP: Updated seek_pos_seconds:%f", seek_pos_seconds);
                }
                trickStartUTCMS = -1;
 
                SyncBegin();
                mProgressReportFromProcessDiscontinuity = true;
                SyncEnd();
 
                // To notify app of discontinuity processing complete
                ReportProgress();
 
                // There is a chance some other operation maybe invoked from JS/App because of the above ReportProgress
                // Make sure we have still mDiscontinuityTuneOperationInProgress set
                SyncBegin();
                AAMPLOG_WARN("Progress event sent as part of ProcessPendingDiscontinuity, mDiscontinuityTuneOperationInProgress:%d", mDiscontinuityTuneOperationInProgress);
                mProgressReportFromProcessDiscontinuity = false;
                continueDiscontProcessing = mDiscontinuityTuneOperationInProgress;
                SyncEnd();
 
                if (continueDiscontProcessing)
                {
                        // mStreamLock is not exactly required here, this will be called from Scheduler/GMainLoop based on AAMP config
                        // The same thread will be executing operations involving TeardownStream.
                        mpStreamAbstractionAAMP->StopInjection();
#ifndef AAMP_STOP_SINK_ON_SEEK
                        if (mMediaFormat != eMEDIAFORMAT_HLS_MP4) // Avoid calling flush for fmp4 playback.
                        {
                                mStreamSink->Flush(mpStreamAbstractionAAMP->GetFirstPTS(), rate);
                        }
#else
                        mStreamSink->Stop(true);
#endif
                        mpStreamAbstractionAAMP->GetStreamFormat(mVideoFormat, mAudioFormat, mAuxFormat, mSubtitleFormat);
                        mStreamSink->Configure(
                                mVideoFormat,
                                mAudioFormat,
                                mAuxFormat,
                                mSubtitleFormat,
                                mpStreamAbstractionAAMP->GetESChangeStatus(),
                                mpStreamAbstractionAAMP->GetAudioFwdToAuxStatus(),
                                mIsTrackIdMismatch /*setReadyAfterPipelineCreation*/);
                        mpStreamAbstractionAAMP->ResetESChangeStatus();
                        mpStreamAbstractionAAMP->StartInjection();
                        mStreamSink->Stream();
                        mIsTrackIdMismatch = false;                     
                }
                else
                {
                        ret = false;
                        AAMPLOG_WARN("PrivateInstanceAAMP: mDiscontinuityTuneOperationInProgress was reset during operation, since other command received from app!");
                }
        }
 
        if (ret)
        {
                SyncBegin();
                mDiscontinuityTuneOperationInProgress = false;
                SyncEnd();
        }
 
        UnblockWaitForDiscontinuityProcessToComplete();
        return ret;
}
 
/**
 * @brief Get the Current Audio Track Id 
 * Currently it is implimented for AC4 track selection only
 * @return int return the index number of current audio track selected
 */ 
int PrivateInstanceAAMP::GetCurrentAudioTrackId()
{
        int trackId = -1;
        AudioTrackInfo currentAudioTrack;
 
        /** Only select track Id for setting gstplayer in case of muxed ac4 stream */
        if (mpStreamAbstractionAAMP->GetCurrentAudioTrack(currentAudioTrack) && (currentAudioTrack.codec.find("ac4") == std::string::npos) && currentAudioTrack.isMuxed )
        {
                AAMPLOG_INFO("Found AC4 track as current Audio track  index = %s language - %s role - %s codec %s type %s bandwidth = %ld",
                currentAudioTrack.index.c_str(), currentAudioTrack.language.c_str(), currentAudioTrack.rendition.c_str(), 
                currentAudioTrack.codec.c_str(), currentAudioTrack.contentType.c_str(), currentAudioTrack.bandwidth);
                trackId = std::stoi( currentAudioTrack.index );
 
        }
 
        return trackId;
}
 
/**
 * @brief Process EOS from Sink and notify listeners if required
 */
void PrivateInstanceAAMP::NotifyEOSReached()
{
        bool isDiscontinuity = IsDiscontinuityProcessPending();
        bool isLive = IsLive();
        
        AAMPLOG_WARN("Enter . processingDiscontinuity %d isLive %d", isDiscontinuity, isLive);
        
        if (!isDiscontinuity)
        {
                /*
                A temporary work around intended to reduce occurrences of LLAMA-6113.
                This appears to be caused by late calls to previously stopped/destroyed objects due to a scheduling issue.
                In this case it makes sense to exit this function ASAP.
                A more complete (larger, higher risk, more time consuming, threadsafe) change to scheduling is required in the future.
                */
                if(!mpStreamAbstractionAAMP)
                {
                        AAMPLOG_ERR("null Stream Abstraction AAMP");
                        return;
                }
 
                if (!mpStreamAbstractionAAMP->IsEOSReached())
                {
                        AAMPLOG_ERR("Bogus EOS event received from GStreamer, discarding it!");
                        return;
                }
                if (!isLive && rate > 0)
                {
                        SetState(eSTATE_COMPLETE);
                        SendEvent(std::make_shared<AAMPEventObject>(AAMP_EVENT_EOS),AAMP_EVENT_ASYNC_MODE);
                        if (ContentType_EAS == mContentType) //Fix for DELIA-25590
                        {
                                mStreamSink->Stop(false);
                        }
                        SendAnomalyEvent(ANOMALY_TRACE, "Generating EOS event");
                        trickStartUTCMS = -1;
                        return;
                }
 
                if (rate < 0)
                {
                        seek_pos_seconds = culledSeconds;
                        AAMPLOG_WARN("Updated seek_pos_seconds %f on BOS", seek_pos_seconds);
                        if (trickStartUTCMS == -1)
                        {
                                // Resetting trickStartUTCMS if it's default due to no first frame on high speed rewind. This enables ReportProgress to 
                                // send BOS event to JSPP
                                ResetTrickStartUTCTime();
                                AAMPLOG_INFO("Resetting trickStartUTCMS to %lld since no first frame on trick play rate %f", trickStartUTCMS, rate);
                        }
                        // A new report progress event to be emitted with position 0 when rewind reaches BOS
                        ReportProgress(true, true);
                        rate = AAMP_NORMAL_PLAY_RATE;
                        AcquireStreamLock();
                        TuneHelper(eTUNETYPE_SEEK);
                        ReleaseStreamLock();
                }
                else
                {
                        rate = AAMP_NORMAL_PLAY_RATE;
                        AcquireStreamLock();
                        TuneHelper(eTUNETYPE_SEEKTOLIVE);
                        ReleaseStreamLock();
                }
 
                NotifySpeedChanged(rate);
        }
        else
        {
                ProcessPendingDiscontinuity();
                pthread_cond_signal(&mCondDiscontinuity);
                DeliverAdEvents();
                AAMPLOG_WARN("PrivateInstanceAAMP:  EOS due to discontinuity handled");
        }
}
 
/**
 * @brief Notify when entering live point to listeners
 */
void PrivateInstanceAAMP::NotifyOnEnteringLive()
{
        if (discardEnteringLiveEvt)
        {
                return;
        }
        SendEvent(std::make_shared<AAMPEventObject>(AAMP_EVENT_ENTERING_LIVE),AAMP_EVENT_ASYNC_MODE);
}
 
/**
 * @brief track description string from TrackType enum
 */
static std::string TrackTypeString(const int track)
{
        switch(track)
        {
                case eTRACK_VIDEO:
                        return "Video";
                case eTRACK_AUDIO:
                        return "Audio";
                case eTRACK_SUBTITLE:
                        return "Subtitle";
                case eTRACK_AUX_AUDIO:
                        return "Aux Audio";
        }
        return "unknown track type";
}
 
/**
* @brief Additional Tune Fail Diagnostics
 */
void PrivateInstanceAAMP::AdditionalTuneFailLogEntries()
{
        mStreamSink->DumpStatus();
 
        {
                std::string downloadsBlockedMessage = "Downloads";
                if (!mbDownloadsBlocked)
                {
                        downloadsBlockedMessage += " not";
                }
                downloadsBlockedMessage += " blocked, track download status: ";
                for (int i = 0; i < AAMP_TRACK_COUNT; i++)
                {
                        downloadsBlockedMessage+=TrackTypeString(i);
                        if (!mbTrackDownloadsBlocked[i])
                        {
                                downloadsBlockedMessage += " not";
                        }
                        downloadsBlockedMessage += " blocked, ";
                }
                AAMPLOG_WARN("%s", downloadsBlockedMessage.c_str());
        }
 
        {
                std::string injectionBlockedMessage = "Track injection status: ";
                for (int i = 0; i < AAMP_TRACK_COUNT; i++)
                {
                        injectionBlockedMessage+=TrackTypeString(i);
                        if (!mTrackInjectionBlocked[i])
                        {
                                injectionBlockedMessage += " not";
                        }
                        injectionBlockedMessage += " blocked, ";
                }
                AAMPLOG_WARN("%s", injectionBlockedMessage.c_str());
        }
        
        if(mpStreamAbstractionAAMP)
        {
                std::string trackBufferStatusMessage = "Track buffer status: ";
                for (int i = 0; i < AAMP_TRACK_COUNT; i++)
                {
                        trackBufferStatusMessage+=TrackTypeString(i);
                        auto track = mpStreamAbstractionAAMP->GetMediaTrack(static_cast<TrackType>(i));
                        if(nullptr != track)
                        {
                                const auto status = track->GetBufferStatus();
                                trackBufferStatusMessage += " ";
                                switch (status)
                                {
                                        case BUFFER_STATUS_GREEN:
                                                trackBufferStatusMessage += "green";
                                                break;
                                        case BUFFER_STATUS_YELLOW:
                                                trackBufferStatusMessage += "yellow";
                                                break;
                                        case BUFFER_STATUS_RED:
                                                trackBufferStatusMessage += "red";
                                                break;
                                        default:
                                                trackBufferStatusMessage += "unknown";
                                                break;
                                }
                        }
                        else
                        {
                                trackBufferStatusMessage += "invalid track";
                        }
                        trackBufferStatusMessage += ", ";
                }
                AAMPLOG_WARN( "%s", trackBufferStatusMessage.c_str());
        }
}
 
/**
 * @brief Profiler for failure tune
 */
void PrivateInstanceAAMP::TuneFail(bool fail)
{
        PrivAAMPState state;
        GetState(state);
        TuneEndMetrics mTuneMetrics = {0, 0, 0,0,0,0,0,0,0,(ContentType)0};     
        mTuneMetrics.mTotalTime                 = NOW_STEADY_TS_MS ;
        mTuneMetrics.success                    = ((state != eSTATE_ERROR) ? -1 : !fail);
        int streamType                          = getStreamType();
        mTuneMetrics.mFirstTune                 = mFirstTune;
        mTuneMetrics.mTimedMetadata             = timedMetadata.size();
        mTuneMetrics.mTimedMetadataStartTime    = mTimedMetadataStartTime;
        mTuneMetrics.mTimedMetadataDuration     = mTimedMetadataDuration;
        mTuneMetrics.mTuneAttempts              = mTuneAttempts;
        mTuneMetrics.contentType                = mContentType;
        mTuneMetrics.streamType                 = streamType;
        mTuneMetrics.mTSBEnabled                = mTSBEnabled;
        if(mTuneMetrics.success  == -1 && mPlayerPreBuffered)
        {
                LogPlayerPreBuffered();        //Need to calculate prebufferedtime when tune interruption happens with playerprebuffer
        }
        profiler.TuneEnd(mTuneMetrics, mAppName,(mbPlayEnabled?STRFGPLAYER:STRBGPLAYER), mPlayerId, mPlayerPreBuffered, durationSeconds, activeInterfaceWifi,mFailureReason);
        AdditionalTuneFailLogEntries();
}
 
/**
 *  @brief Notify tune end for profiling/logging
 */
void PrivateInstanceAAMP::LogTuneComplete(void)
{
        TuneEndMetrics mTuneMetrics = {0, 0, 0,0,0,0,0,0,0,(ContentType)0};
        
        mTuneMetrics.success                     = true; 
        int streamType                           = getStreamType();
        mTuneMetrics.contentType                 = mContentType;
        mTuneMetrics.mTimedMetadata              = timedMetadata.size();
        mTuneMetrics.mTimedMetadataStartTime     = mTimedMetadataStartTime;
        mTuneMetrics.mTimedMetadataDuration      = mTimedMetadataDuration;
        mTuneMetrics.mTuneAttempts               = mTuneAttempts;
        mTuneMetrics.streamType                  = streamType;
        mTuneMetrics.mTSBEnabled                 = mTSBEnabled;
        profiler.TuneEnd(mTuneMetrics,mAppName,(mbPlayEnabled?STRFGPLAYER:STRBGPLAYER), mPlayerId, mPlayerPreBuffered, durationSeconds, activeInterfaceWifi,mFailureReason);
        //update tunedManifestUrl if FOG was NOT used as manifestUrl might be updated with redirected url.
        if(!IsTSBSupported())
        {
                SetTunedManifestUrl(); /* Redirect URL in case on VOD */
        }
 
        if (!mTuneCompleted)
        {
                if(mLogTune)
                {
                        char classicTuneStr[AAMP_MAX_PIPE_DATA_SIZE];
                        mLogTune = false;
                        if (ISCONFIGSET_PRIV(eAAMPConfig_XRESupportedTune)) { 
                                profiler.GetClassicTuneTimeInfo(mTuneMetrics.success, mTuneAttempts, mfirstTuneFmt, mPlayerLoadTime, streamType, IsLive(), durationSeconds, classicTuneStr);
                                SendMessage2Receiver(E_AAMP2Receiver_TUNETIME,classicTuneStr);
                        }
                        mTuneCompleted = true;
                        mFirstTune = false;
                }
                AAMPAnomalyMessageType eMsgType = AAMPAnomalyMessageType::ANOMALY_TRACE;
                if(mTuneAttempts > 1 )
                {
                    eMsgType = AAMPAnomalyMessageType::ANOMALY_WARNING;
                }
                std::string playbackType = GetContentTypString();
 
                if(mContentType == ContentType_LINEAR)
                {
                        if(mTSBEnabled)
                        {
                                playbackType.append(":TSB=true");
                        }
                        else
                        {
                                playbackType.append(":TSB=false");
                        }
                }
 
                SendAnomalyEvent(eMsgType, "Tune attempt#%d. %s:%s URL:%s", mTuneAttempts,playbackType.c_str(),getStreamTypeString().c_str(),GetTunedManifestUrl());
        }
        
        mConfig->logging.setLogLevel(eLOGLEVEL_WARN);
        gpGlobalConfig->logging.setLogLevel(eLOGLEVEL_WARN);    
}
 
/**
 *  @brief Notifies profiler that first frame is presented
 */
void PrivateInstanceAAMP::LogFirstFrame(void)
{
        profiler.ProfilePerformed(PROFILE_BUCKET_FIRST_FRAME);
}
 
/**
 *  @brief Profile Player changed from background to foreground i.e prebuffred
 */
void PrivateInstanceAAMP::LogPlayerPreBuffered(void)
{
       profiler.ProfilePerformed(PROFILE_BUCKET_PLAYER_PRE_BUFFERED);
}
 
/**
 *   @brief Notifies profiler that drm initialization is complete 
 */
void PrivateInstanceAAMP::LogDrmInitComplete(void)
{
        profiler.ProfileEnd(PROFILE_BUCKET_LA_TOTAL);
}
 
/**
 *   @brief Notifies profiler that decryption has started
 */
void PrivateInstanceAAMP::LogDrmDecryptBegin(ProfilerBucketType bucketType)
{
        profiler.ProfileBegin(bucketType);
}
 
/**
 *   @brief Notifies profiler that decryption has ended
 */
void PrivateInstanceAAMP::LogDrmDecryptEnd(ProfilerBucketType bucketType)
{
        profiler.ProfileEnd(bucketType);
}
 
/**
 * @brief Stop downloads of all tracks.
 * Used by aamp internally to manage states
 */
void PrivateInstanceAAMP::StopDownloads()
{
        AAMPLOG_TRACE ("PrivateInstanceAAMP");
        if (!mbDownloadsBlocked)
        {
                pthread_mutex_lock(&mLock);
                mbDownloadsBlocked = true;
                pthread_mutex_unlock(&mLock);
        }
}
 
/**
 * @brief Resume downloads of all tracks.
 * Used by aamp internally to manage states
 */
void PrivateInstanceAAMP::ResumeDownloads()
{
        AAMPLOG_TRACE ("PrivateInstanceAAMP");
        if (mbDownloadsBlocked)
        {
                pthread_mutex_lock(&mLock);
                mbDownloadsBlocked = false;
                //log_current_time("gstreamer-needs-data");
                pthread_mutex_unlock(&mLock);
        }
}
 
/**
 * @brief Stop downloads for a track.
 * Called from StreamSink to control flow
 */
void PrivateInstanceAAMP::StopTrackDownloads(MediaType type)
{ // called from gstreamer main event loop
#ifdef AAMP_DEBUG_FETCH_INJECT
        if ((1 << type) & AAMP_DEBUG_FETCH_INJECT)
        {
                AAMPLOG_WARN ("PrivateInstanceAAMP: Enter. type = %d", (int) type);
        }
#endif
        if (!mbTrackDownloadsBlocked[type])
        {
                AAMPLOG_TRACE("gstreamer-enough-data from source[%d]", type);
                pthread_mutex_lock(&mLock);
                mbTrackDownloadsBlocked[type] = true;
                pthread_mutex_unlock(&mLock);
                NotifySinkBufferFull(type);
        }
        AAMPLOG_TRACE ("PrivateInstanceAAMP:: Enter. type = %d",  (int) type);
}
 
/**
 * @brief Resume downloads for a track.
 * Called from StreamSink to control flow
 */
void PrivateInstanceAAMP::ResumeTrackDownloads(MediaType type)
{ // called from gstreamer main event loop
#ifdef AAMP_DEBUG_FETCH_INJECT
        if ((1 << type) & AAMP_DEBUG_FETCH_INJECT)
        {
                AAMPLOG_WARN ("PrivateInstanceAAMP: Enter. type = %d", (int) type);
        }
#endif
        if (mbTrackDownloadsBlocked[type])
        {
                AAMPLOG_TRACE("gstreamer-needs-data from source[%d]", type);
                pthread_mutex_lock(&mLock);
                mbTrackDownloadsBlocked[type] = false;
                //log_current_time("gstreamer-needs-data");
                pthread_mutex_unlock(&mLock);
        }
        AAMPLOG_TRACE ("PrivateInstanceAAMP::Exit. type = %d",  (int) type);
}
 
/**
 *  @brief Block the injector thread until the gstreanmer needs buffer/more data.
 */
void PrivateInstanceAAMP::BlockUntilGstreamerWantsData(void(*cb)(void), int periodMs, int track)
{ // called from FragmentCollector thread; blocks until gstreamer wants data
        AAMPLOG_TRACE("PrivateInstanceAAMP::Enter. type = %d and downloads:%d",  track, mbTrackDownloadsBlocked[track]);
        int elapsedMs = 0;
        while (mbDownloadsBlocked || mbTrackDownloadsBlocked[track])
        {
                if (!mDownloadsEnabled || mTrackInjectionBlocked[track])
                {
                        AAMPLOG_WARN("PrivateInstanceAAMP: interrupted. mDownloadsEnabled:%d mTrackInjectionBlocked:%d", mDownloadsEnabled, mTrackInjectionBlocked[track]);
                        break;
                }
                if (cb && periodMs)
                { // support for background tasks, i.e. refreshing manifest while gstreamer doesn't need additional data
                        if (elapsedMs >= periodMs)
                        {
                                cb();
                                elapsedMs -= periodMs;
                        }
                        elapsedMs += 10;
                }
                InterruptableMsSleep(10);
        }
        AAMPLOG_TRACE("PrivateInstanceAAMP::Exit. type = %d",  track);
}
 
/**
 * @brief Curl initialization function
 */
void PrivateInstanceAAMP::CurlInit(AampCurlInstance startIdx, unsigned int instanceCount, std::string proxyName)
{
        int instanceEnd = startIdx + instanceCount;
        std::string UserAgentString;
        UserAgentString=mConfig->GetUserAgentString();
        assert (instanceEnd <= eCURLINSTANCE_MAX);
 
        CurlStore::GetCurlStoreInstance(this)->CurlInit(this, startIdx, instanceCount, proxyName);
}
 
/**
 * @brief Storing audio language list
 */
void PrivateInstanceAAMP::StoreLanguageList(const std::set<std::string> &langlist)
{
        // store the language list
        int langCount = langlist.size();
        if (langCount > MAX_LANGUAGE_COUNT)
        {
                langCount = MAX_LANGUAGE_COUNT; //boundary check
        }
        mMaxLanguageCount = langCount;
        std::set<std::string>::const_iterator iter = langlist.begin();
        for (int cnt = 0; cnt < langCount; cnt++, iter++)
        {
                strncpy(mLanguageList[cnt], iter->c_str(), MAX_LANGUAGE_TAG_LENGTH);
                mLanguageList[cnt][MAX_LANGUAGE_TAG_LENGTH-1] = 0;
                if( this->mVideoEnd )
                {
                        mVideoEnd->Setlanguage(VideoStatTrackType::STAT_AUDIO, (*iter), cnt+1);
                }
        }
}
 
/**
 * @brief Checking whether audio language supported
 */
bool PrivateInstanceAAMP::IsAudioLanguageSupported (const char *checkLanguage)
{
        bool retVal =false;
        for (int cnt=0; cnt < mMaxLanguageCount; cnt ++)
        {
                if(strncmp(mLanguageList[cnt], checkLanguage, MAX_LANGUAGE_TAG_LENGTH) == 0)
                {
                        retVal = true;
                        break;
                }
        }
 
        if(mMaxLanguageCount == 0)
        {
                AAMPLOG_WARN("IsAudioLanguageSupported No Audio language stored !!!");
        }
        else if(!retVal)
        {
                AAMPLOG_WARN("IsAudioLanguageSupported lang[%s] not available in list",checkLanguage);
        }
        return retVal;
}
 
/**
 * @brief Set curl timeout(CURLOPT_TIMEOUT)
 */
void PrivateInstanceAAMP::SetCurlTimeout(long timeoutMS, AampCurlInstance instance)
{
        if(ContentType_EAS == mContentType)
                return;
        if(instance < eCURLINSTANCE_MAX && curl[instance])
        {
                CURL_EASY_SETOPT(curl[instance], CURLOPT_TIMEOUT_MS, timeoutMS);
                curlDLTimeout[instance] = timeoutMS;
        }
        else
        {
                AAMPLOG_WARN("Failed to update timeout for curl instace %d",instance);
        }
}
 
/**
 * @brief Terminate curl contexts
 */
void PrivateInstanceAAMP::CurlTerm(AampCurlInstance startIdx, unsigned int instanceCount)
{
        int instanceEnd = startIdx + instanceCount;
        assert (instanceEnd <= eCURLINSTANCE_MAX);
 
        if (ISCONFIGSET_PRIV(eAAMPConfig_EnableCurlStore) && \
                ( startIdx == eCURLINSTANCE_VIDEO ) && (eCURLINSTANCE_AUX_AUDIO < instanceEnd) )
        {
                for(int i=0; i<eCURLINSTANCE_MAX;++i)
                {
                        if(curlhost[i]->curl)
                        {
                                CurlStore::GetCurlStoreInstance(this)->CurlTerm(this, (AampCurlInstance)i, 1, curlhost[i]->hostname);
                        }
                        curlhost[i]->isRemotehost=true;
                        curlhost[i]->redirect=true;
                }
        }
 
        CurlStore::GetCurlStoreInstance(this)->CurlTerm(this, startIdx, instanceCount);
}
 
/**
 * @brief GetPlaylistCurlInstance -  Function to return the curl instance for playlist download
 * Considers parallel download to decide the curl instance 
 * @return AampCurlInstance - curl instance for download
 */
AampCurlInstance PrivateInstanceAAMP::GetPlaylistCurlInstance(MediaType type, bool isInitialDownload)
{
        AampCurlInstance retType = eCURLINSTANCE_MANIFEST_PLAYLIST;
        bool indivCurlInstanceFlag = false;
 
        //DELIA-41646
        // logic behind this function :
        // a. This function gets called during Init and during Refresh of playlist .So need to decide who called
        // b. Based on the decision flag is considerd . mParallelFetchPlaylist for Init and mParallelFetchPlaylistRefresh
        //        for refresh
        // c. If respective configuration is enabled , then associate separate curl for each track type
        // d. If parallel fetch is disabled , then single curl instance is used to fetch all playlist(eCURLINSTANCE_MANIFEST_PLAYLIST)
 
        indivCurlInstanceFlag = isInitialDownload ? ISCONFIGSET_PRIV(eAAMPConfig_PlaylistParallelFetch) : ISCONFIGSET_PRIV(eAAMPConfig_PlaylistParallelRefresh);
        if(indivCurlInstanceFlag)
        {
                switch(type)
                {
                        case eMEDIATYPE_PLAYLIST_VIDEO:
                                retType = eCURLINSTANCE_VIDEO;
                                break;
                        case eMEDIATYPE_PLAYLIST_AUDIO:
                                retType = eCURLINSTANCE_AUDIO;
                                break;
                        case eMEDIATYPE_PLAYLIST_SUBTITLE:
                                retType = eCURLINSTANCE_SUBTITLE;
                                break;
                        case eMEDIATYPE_PLAYLIST_AUX_AUDIO:
                                retType = eCURLINSTANCE_AUX_AUDIO;
                                break;
                        default:
                                break;
                }
        }
        return retType;
}
 
/**
 * @brief Reset bandwidth value
 * Artificially resetting the bandwidth. Low for quicker tune times
 */
void PrivateInstanceAAMP::ResetCurrentlyAvailableBandwidth(long bitsPerSecond , bool trickPlay,int profile)
{
        pthread_mutex_lock(&mLock);
        if (mAbrBitrateData.size())
        {
                mAbrBitrateData.erase(mAbrBitrateData.begin(),mAbrBitrateData.end());
        }
        pthread_mutex_unlock(&mLock);
}
 
/**
 * @brief Get the current network bandwidth
 * using most recently recorded 3 samples
 * @return Available bandwidth in bps
 */
long PrivateInstanceAAMP::GetCurrentlyAvailableBandwidth(void)
{
        // 1. Check for any old bitrate beyond threshold time . remove those before calculation
        // 2. Sort and get median 
        // 3. if any outliers  , remove those entries based on a threshold value.
        // 4. Get the average of remaining data. 
        // 5. if no item in the list , return -1 . Caller to ignore bandwidth based processing
        
        std::vector< long> tmpData;
        long ret = -1;
        pthread_mutex_lock(&mLock);
        mhAbrManager.UpdateABRBitrateDataBasedOnCacheLife(mAbrBitrateData,tmpData);
        pthread_mutex_unlock(&mLock);
                
                if (tmpData.size())
                {
                        //AAMPLOG_WARN("NwBW with newlogic size[%d] avg[%ld] ",tmpData.size(), avg/tmpData.size());
                        ret =mhAbrManager.UpdateABRBitrateDataBasedOnCacheOutlier(tmpData);
                        mAvailableBandwidth = ret;
                        //Store the PersistBandwidth and UpdatedTime on ABRManager
                        //Bitrate Update only for foreground player
                        if(ISCONFIGSET_PRIV(eAAMPConfig_PersistLowNetworkBandwidth)||ISCONFIGSET_PRIV(eAAMPConfig_PersistHighNetworkBandwidth))
                        {
                                if(mAvailableBandwidth  > 0 && mbPlayEnabled)
                                {
                                        ABRManager::setPersistBandwidth(mAvailableBandwidth );
                                        ABRManager::mPersistBandwidthUpdatedTime = aamp_GetCurrentTimeMS();
                                }
                        }
                }
                else
                {
                        //AAMPLOG_WARN("No prior data available for abr , return -1 ");
                        ret = -1;
                }
        
        return ret;
}
 
/**
 * @brief get Media Type in string
 */ 
const char* PrivateInstanceAAMP::MediaTypeString(MediaType fileType)
{
        switch(fileType)
        {
                case eMEDIATYPE_VIDEO:
                case eMEDIATYPE_INIT_VIDEO:
                        return "VIDEO";
                case eMEDIATYPE_AUDIO:
                case eMEDIATYPE_INIT_AUDIO:
                        return "AUDIO";
                case eMEDIATYPE_SUBTITLE:
                case eMEDIATYPE_INIT_SUBTITLE:
                        return "SUBTITLE";
                case eMEDIATYPE_AUX_AUDIO:
                case eMEDIATYPE_INIT_AUX_AUDIO:
                        return "AUX-AUDIO";
                case eMEDIATYPE_MANIFEST:
                        return "MANIFEST";
                case eMEDIATYPE_LICENCE:
                        return "LICENCE";
                case eMEDIATYPE_IFRAME:
                        return "IFRAME";
                case eMEDIATYPE_PLAYLIST_VIDEO:
                        return "PLAYLIST_VIDEO";
                case eMEDIATYPE_PLAYLIST_AUDIO:
                        return "PLAYLIST_AUDIO";
                case eMEDIATYPE_PLAYLIST_SUBTITLE:
                        return "PLAYLIST_SUBTITLE";
                case eMEDIATYPE_PLAYLIST_AUX_AUDIO:
                        return "PLAYLIST_AUX-AUDIO";
                default:
                        return "Unknown";
        }
}
 
/**
 * @brief Download a file from the server
 */
bool PrivateInstanceAAMP::GetNetworkTime(enum UtcTiming timingType, const std::string& remoteUrl, long *http_error, CurlRequest request)
{
    bool ret = false;
 
    CURLcode res;
    long httpCode = -1;
 
    if(eCURL_GET != request)
        return ret;
 
    CURL *curl = curl_easy_init();
    if(curl)
    {
        AAMPLOG_TRACE("%s, %d", remoteUrl.c_str(), request);
        GrowableBuffer buffer = {0,};
 
        CurlCbContextSyncTime context(this, &buffer);
 
        curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, SyncTime_write_callback);
        curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &context);
        curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
 
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, DEFAULT_CURL_TIMEOUT);
        curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_WHATEVER);
        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
        if(!ISCONFIGSET_PRIV(eAAMPConfig_SslVerifyPeer)){
            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
        }
        else {
            curl_easy_setopt(curl, CURLOPT_SSLVERSION, mSupportedTLSVersion);
            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
        }
 
        curl_easy_setopt(curl, CURLOPT_URL, remoteUrl.c_str());
 
        res = curl_easy_perform(curl);
        if (res == CURLE_OK)
        {
            curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpCode);
            if ((httpCode == 204) || (httpCode == 200))
            {
                if(buffer.len)
                {
                    time_t currentTime;
                    currentTime     = time(0);
                    struct tm *localTime;
                    localTime       = localtime(&currentTime);
                    struct tm *stGMT;
                    stGMT           = gmtime(&currentTime);
                    time_t currentTimeGMT;
                    currentTimeGMT  = mktime(stGMT);
 
                    //2021-06-15T18:11:39Z - UTC Zulu
                    //2021-06-15T19:03:48.795Z - <ProducerReferenceTime> WallClk UTC Zulu
                    const char* format = "%Y-%m-%dT%H:%M:%SZ";
                    mTime = convertTimeToEpoch((const char*)buffer.ptr, format);
                    AAMPLOG_WARN("ProducerReferenceTime Wallclock (Epoch): [%ld]", mTime);
 
                    aamp_Free(&buffer);
 
                    ret = true;
                }
            }
            else
            {
                AAMPLOG_ERR(" Returned [%d]", httpCode);
            }
        }
        else
        {
            AAMPLOG_ERR("Failed to perform curl request, result:%d", res);
        }
 
        if(httpCode > 0)
        {
            *http_error = httpCode;
        }
 
        curl_easy_cleanup(curl);
    }
 
    return ret;
}
 
/**
 * @brief Download a file from the CDN
 */
bool PrivateInstanceAAMP::GetFile(std::string remoteUrl,struct GrowableBuffer *buffer, std::string& effectiveUrl,
                                long * http_error, double *downloadTime, const char *range, unsigned int curlInstance, 
                                bool resetBuffer, MediaType fileType, long *bitrate, int * fogError,
                                double fragmentDurationSeconds,CMCDHeaders *pCMCDMetrics)
{
        MediaType simType = fileType; // remember the requested specific file type; fileType gets overridden later with simple VIDEO/AUDIO
        MediaTypeTelemetry mediaType = aamp_GetMediaTypeForTelemetry(fileType);
        std::unordered_map<std::string, std::vector<std::string>> mCMCDCustomHeaders;
        if((pCMCDMetrics!=NULL) && ISCONFIGSET_PRIV(eAAMPConfig_EnableCMCD))
        {
                CollectCMCDCustomHeaders(fileType,pCMCDMetrics);
                pCMCDMetrics->BuildCMCDCustomHeaders(mCMCDCustomHeaders);
 
        }
        long http_code = -1;
        double fileDownloadTime = 0;
        bool ret = false;
        int downloadAttempt = 0;
        int maxDownloadAttempt = 1;
        CURL* curl = this->curl[curlInstance];
        struct curl_slist* httpHeaders = NULL;
        CURLcode res = CURLE_OK;
        int fragmentDurationMs = (int)(fragmentDurationSeconds*1000);/*convert to MS */
        if (simType == eMEDIATYPE_INIT_VIDEO || simType == eMEDIATYPE_INIT_AUDIO || simType == eMEDIATYPE_INIT_AUX_AUDIO)
        {
                int InitFragmentRetryCount;
                GETCONFIGVALUE_PRIV(eAAMPConfig_InitFragmentRetryCount,InitFragmentRetryCount); 
                maxDownloadAttempt += InitFragmentRetryCount;
        }
        else
        {
                maxDownloadAttempt += DEFAULT_DOWNLOAD_RETRY_COUNT;
        }
 
        if (resetBuffer)
        {
                if(buffer->avail)
                {
                        AAMPLOG_TRACE("reset buffer %p avail %d", buffer, (int)buffer->avail);
                }       
                memset(buffer, 0x00, sizeof(*buffer));
        }
        if (mDownloadsEnabled)
        {
                int downloadTimeMS = 0;
                bool isDownloadStalled = false;
                CurlAbortReason abortReason = eCURL_ABORT_REASON_NONE;
                double connectTime = 0;
                pthread_mutex_unlock(&mLock);
                std::string uriParameter;
                GETCONFIGVALUE_PRIV(eAAMPConfig_URIParameter,uriParameter);
                // append custom uri parameter with remoteUrl at the end before curl request if curlHeader logging enabled.
                if (ISCONFIGSET_PRIV(eAAMPConfig_CurlHeader) && (!uriParameter.empty()) && simType == eMEDIATYPE_MANIFEST)
                {
                        if (remoteUrl.find("?") == std::string::npos)
                        {
                                uriParameter[0] = '?';
                        }
 
                        remoteUrl.append(uriParameter.c_str());
                        //printf ("URL after appending uriParameter :: %s\n", remoteUrl.c_str());
                }
 
                if(ISCONFIGSET_PRIV(eAAMPConfig_EnableCurlStore) && mOrigManifestUrl.isRemotehost )
                {
                        if( curlhost[curlInstance]->isRemotehost && curlhost[curlInstance]->redirect &&
                                ( NULL == curlhost[curlInstance]->curl || std::string::npos == remoteUrl.find(curlhost[curlInstance]->hostname)) )
                        {
                                if(NULL != curlhost[curlInstance]->curl)
                                {
                                        CurlStore::GetCurlStoreInstance(this)->CurlTerm(this, (AampCurlInstance)curlInstance, 1, curlhost[curlInstance]->hostname);
                                }
 
                                curlhost[curlInstance]->hostname = aamp_getHostFromURL(remoteUrl);
                                curlhost[curlInstance]->isRemotehost =!(aamp_IsLocalHost(curlhost[curlInstance]->hostname));
                                curlhost[curlInstance]->redirect = false;
 
                                if( curlhost[curlInstance]->isRemotehost && (std::string::npos == mOrigManifestUrl.hostname.find(curlhost[curlInstance]->hostname)) )
                                {
                                        CurlStore::GetCurlStoreInstance(this)->CurlInit(this, (AampCurlInstance)curlInstance, 1, GetNetworkProxy(), curlhost[curlInstance]->hostname);
                                        CURL_EASY_SETOPT(curlhost[curlInstance]->curl, CURLOPT_TIMEOUT_MS, curlDLTimeout[curlInstance]);
                                }
                        }
 
                        if ( curlhost[curlInstance]->curl )
                        curl=curlhost[curlInstance]->curl;
                }
 
                AAMPLOG_INFO("aamp url:%d,%d,%d,%f,%s", mediaType, simType, curlInstance,fragmentDurationSeconds, remoteUrl.c_str());
                CurlCallbackContext context;
                if (curl)
                {
                        CURL_EASY_SETOPT(curl, CURLOPT_URL, remoteUrl.c_str());
                        if(this->mAampLLDashServiceData.lowLatencyMode)
                        {
                                CURL_EASY_SETOPT(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
                                context.remoteUrl = remoteUrl;
                        }
                        context.aamp = this;
                        context.buffer = buffer;
                        context.responseHeaderData = &httpRespHeaders[curlInstance];
                        context.fileType = simType;
                        
                        if(!this->mAampLLDashServiceData.lowLatencyMode)
                        {
                                CURL_EASY_SETOPT(curl, CURLOPT_WRITEDATA, &context);
                                CURL_EASY_SETOPT(curl, CURLOPT_HEADERDATA, &context);
                        }
                        if(!ISCONFIGSET_PRIV(eAAMPConfig_SslVerifyPeer))
                        {
                                CURL_EASY_SETOPT(curl, CURLOPT_SSL_VERIFYHOST, 0L);
                                CURL_EASY_SETOPT(curl, CURLOPT_SSL_VERIFYPEER, 0L);
                        }
                        else
                        {
                                CURL_EASY_SETOPT(curl, CURLOPT_SSLVERSION, mSupportedTLSVersion);
                                CURL_EASY_SETOPT(curl, CURLOPT_SSL_VERIFYPEER, 1L);
                        }
 
                        CurlProgressCbContext progressCtx;
                        progressCtx.aamp = this;
                        progressCtx.fileType = simType;
                        progressCtx.dlStarted = true;
                        progressCtx.fragmentDurationMs = fragmentDurationMs;
 
                        if(this->mAampLLDashServiceData.lowLatencyMode &&
                        (simType == eMEDIATYPE_VIDEO))
                        {
                                progressCtx.remoteUrl = remoteUrl;
                        }
 
                        //Disable download stall detection checks for FOG playback done by JS PP
                        if(simType == eMEDIATYPE_MANIFEST || simType == eMEDIATYPE_PLAYLIST_VIDEO ||
                                simType == eMEDIATYPE_PLAYLIST_AUDIO || simType == eMEDIATYPE_PLAYLIST_SUBTITLE ||
                                simType == eMEDIATYPE_PLAYLIST_IFRAME || simType == eMEDIATYPE_PLAYLIST_AUX_AUDIO)
                        {
                                // For Manifest file : Set starttimeout to 0 ( no wait for first byte). Playlist/Manifest with DAI
                                // contents take more time , hence to avoid frequent timeout, its set as 0
                                progressCtx.startTimeout = 0;
                        }
                        else
                        {
                                // for Video/Audio segments , set the start timeout as configured by Application
                                GETCONFIGVALUE_PRIV(eAAMPConfig_CurlDownloadStartTimeout,progressCtx.startTimeout);
                                GETCONFIGVALUE_PRIV(eAAMPConfig_CurlDownloadLowBWTimeout,progressCtx.lowBWTimeout);
                        }
                        GETCONFIGVALUE_PRIV(eAAMPConfig_CurlStallTimeout,progressCtx.stallTimeout);
 
                        // note: win32 curl lib doesn't support multi-part range
                        CURL_EASY_SETOPT(curl, CURLOPT_RANGE, range);
 
                        if ((httpRespHeaders[curlInstance].type == eHTTPHEADERTYPE_COOKIE) && (httpRespHeaders[curlInstance].data.length() > 0))
                        {
                                AAMPLOG_TRACE("Appending cookie headers to HTTP request");
                                //curl_easy_setopt(curl, CURLOPT_COOKIE, cookieHeaders[curlInstance].c_str());
                                CURL_EASY_SETOPT(curl, CURLOPT_COOKIE, httpRespHeaders[curlInstance].data.c_str());
                        }
                        if ( ISCONFIGSET_PRIV(eAAMPConfig_EnableCMCD) && mCMCDCustomHeaders.size() > 0)
                        {
                                std::string customHeader;
                                std::string headerValue;
                                for (std::unordered_map<std::string, std::vector<std::string>>::iterator it = mCMCDCustomHeaders.begin();it != mCMCDCustomHeaders.end(); it++)
                                {
                                        customHeader.clear();
                                        headerValue.clear();
                                        customHeader.insert(0, it->first);
                                        customHeader.push_back(' ');
                                        if (it->first.compare("CMCD-Session:") == 0)
                                        {
                                                headerValue = it->second.at(0);
                                        }
                                        if (it->first.compare("CMCD-Object:") == 0)
                                        {
                                                headerValue = it->second.at(0);
                                        }
                                        if (it->first.compare("CMCD-Request:") == 0)
                                        {
                                                headerValue = it->second.at(0);
                                        }
                                        if (it->first.compare("CMCD-Status:") == 0)
                                        {
                                                headerValue = it->second.at(0);
                                        }
                                        customHeader.append(headerValue);
                                        httpHeaders = curl_slist_append(httpHeaders, customHeader.c_str());
                                }
 
                        }
                        if (mCustomHeaders.size() > 0)
                        {
                                std::string customHeader;
                                std::string headerValue;
                                for (std::unordered_map<std::string, std::vector<std::string>>::iterator it = mCustomHeaders.begin();
                                                                        it != mCustomHeaders.end(); it++)
                                {
                                        customHeader.clear();
                                        headerValue.clear();
                                        customHeader.insert(0, it->first);
                                        customHeader.push_back(' ');
                                        headerValue = it->second.at(0);
                                        if (it->first.compare("X-MoneyTrace:") == 0)
                                        {
                                                if (mTSBEnabled && !mIsFirstRequestToFOG)
                                                {
                                                        continue;
                                                }
                                                char buf[512];
                                                memset(buf, '\0', 512);
                                                if (it->second.size() >= 2)
                                                {
                                                        snprintf(buf, 512, "trace-id=%s;parent-id=%s;span-id=%lld",
                                                                        (const char*)it->second.at(0).c_str(),
                                                                        (const char*)it->second.at(1).c_str(),
                                                                        aamp_GetCurrentTimeMS());
                                                }
                                                else if (it->second.size() == 1)
                                                {
                                                        snprintf(buf, 512, "trace-id=%s;parent-id=%lld;span-id=%lld",
                                                                        (const char*)it->second.at(0).c_str(),
                                                                        aamp_GetCurrentTimeMS(),
                                                                        aamp_GetCurrentTimeMS());
                                                }
                                                headerValue = buf;
                                        }
                                        if (it->first.compare("Wifi:") == 0)
                                        {
                                                if (true == activeInterfaceWifi)
                                                {
                                                        headerValue = "1";
                                                }
                                                else
                                                {
                                                         headerValue = "0";
                                                }
                                        }
                                        customHeader.append(headerValue);
                                        httpHeaders = curl_slist_append(httpHeaders, customHeader.c_str());
                                }
                                if (ISCONFIGSET_PRIV(eAAMPConfig_LimitResolution) && mIsFirstRequestToFOG && mTSBEnabled && eMEDIATYPE_MANIFEST == simType)
                                {
                                        std::string customHeader;
                                        customHeader.clear();
                                        customHeader = "width: " +  std::to_string(mDisplayWidth);
                                        httpHeaders = curl_slist_append(httpHeaders, customHeader.c_str());
                                        customHeader.clear();
                                        customHeader = "height: " + std::to_string(mDisplayHeight);
                                        httpHeaders = curl_slist_append(httpHeaders, customHeader.c_str());
                                }
 
                                if(mTSBEnabled  && eMEDIATYPE_VIDEO == simType)
                                {
                                        double bufferedDuration = mpStreamAbstractionAAMP->GetBufferedVideoDurationSec() * 1000.0;
                                        std::string customHeader;
                                        customHeader.clear();
                                        customHeader = "Buffer: " +std::to_string(bufferedDuration);
                                        httpHeaders = curl_slist_append(httpHeaders, customHeader.c_str());
                                }
                                if(mTSBEnabled  && eMEDIATYPE_AUDIO == simType)
                                {
                                        double bufferedAudioDuration = mpStreamAbstractionAAMP->GetBufferedDuration() * 1000.0;
                                        std::string customHeader;
                                        customHeader.clear();
                                        customHeader = "AudioBuffer: " +std::to_string(bufferedAudioDuration);
                                        httpHeaders = curl_slist_append(httpHeaders, customHeader.c_str());
                                }
                                if(mTSBEnabled && (eMEDIATYPE_VIDEO == simType || eMEDIATYPE_AUDIO == simType))
                                {
                                         MediaTrack* mediaTrack = (eMEDIATYPE_VIDEO == simType)?(mpStreamAbstractionAAMP->GetMediaTrack(eTRACK_VIDEO)):(mpStreamAbstractionAAMP->GetMediaTrack(eTRACK_AUDIO));
                                        if((mediaTrack) && (mediaTrack->GetBufferStatus() == BUFFER_STATUS_RED))
                                        {
                                                std::string customHeader;
                                                customHeader.clear();
                                                customHeader = "BufferStarvation:";
                                                httpHeaders = curl_slist_append(httpHeaders, customHeader.c_str());             
                                        }
                                }
 
                                if (ISCONFIGSET_PRIV(eAAMPConfig_CurlHeader) && (eMEDIATYPE_VIDEO == simType || eMEDIATYPE_PLAYLIST_VIDEO == simType))
                                {
                                        std::string customheaderstr;
                                        GETCONFIGVALUE_PRIV(eAAMPConfig_CustomHeader,customheaderstr);                                  
                                        if(!customheaderstr.empty())
                                        {                               
                                                //AAMPLOG_WARN ("Custom Header Data: Index( %d ) Data( %s )", i, &customheaderstr.at(i));
                                                httpHeaders = curl_slist_append(httpHeaders, customheaderstr.c_str());                                  
                                        }
                                }
 
                                if (mIsFirstRequestToFOG && mTSBEnabled && eMEDIATYPE_MANIFEST == simType)
                                {
                                        std::string customHeader = "4k: 1";
                                        if (ISCONFIGSET_PRIV(eAAMPConfig_Disable4K))
                                        {
                                                customHeader = "4k: 0";
                                        }                                        
                                        httpHeaders = curl_slist_append(httpHeaders, customHeader.c_str());
                                }
 
                                if (httpHeaders != NULL)
                                {
                                        CURL_EASY_SETOPT(curl, CURLOPT_HTTPHEADER, httpHeaders);
                                }
                        }
 
                        while(downloadAttempt < maxDownloadAttempt)
                        {
                                progressCtx.downloadStartTime = NOW_STEADY_TS_MS;
                                                                
                                if(this->mAampLLDashServiceData.lowLatencyMode)
                                {
                                        context.downloadStartTime = progressCtx.downloadStartTime;
                                        CURL_EASY_SETOPT(curl, CURLOPT_WRITEDATA, &context);
                                        CURL_EASY_SETOPT(curl, CURLOPT_HEADERDATA, &context);
                                }
                                progressCtx.downloadUpdatedTime = -1;
                                progressCtx.downloadSize = -1;
                                progressCtx.abortReason = eCURL_ABORT_REASON_NONE;
                                CURL_EASY_SETOPT(curl, CURLOPT_PROGRESSDATA, &progressCtx);
                                if(buffer->ptr != NULL)
                                {
                                        AAMPLOG_TRACE("reset length. buffer %p avail %d",  buffer, (int)buffer->avail);
                                        buffer->len = 0;
                                }
 
                                isDownloadStalled = false;
                                abortReason = eCURL_ABORT_REASON_NONE;
 
                                long long tStartTime = NOW_STEADY_TS_MS;
                                CURLcode res = curl_easy_perform(curl); // synchronous; callbacks allow interruption
 
                                if(!mAampLLDashServiceData.lowLatencyMode)
                                {
                                        int insertDownloadDelay=0;
                                        GETCONFIGVALUE_PRIV(eAAMPConfig_DownloadDelay,insertDownloadDelay);
                                        /* optionally locally induce extra per-download latency */
                                        if( insertDownloadDelay > 0 )
                                        {
                                                InterruptableMsSleep( insertDownloadDelay );
                                        }
                                }
 
                                long long tEndTime = NOW_STEADY_TS_MS;
                                downloadAttempt++;
 
                                downloadTimeMS = (int)(tEndTime - tStartTime);
                                bool loopAgain = false;
                                if (res == CURLE_OK)
                                { // all data collected
                                        if( memcmp(remoteUrl.c_str(), "file:", 5) == 0 )
                                        { // file uri scheme
                                                // libCurl does not provide CURLINFO_RESPONSE_CODE for 'file:' protocol.
                                                // Handle CURL_OK to http_code mapping here, other values handled below (see http_code = res).
                                                http_code = 200;
                                        }
                                        else
                                        {
                                                curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
                                        }
                                        char *effectiveUrlPtr = NULL;
                                        if (http_code != 200 && http_code != 204 && http_code != 206)
                                        {
                                                AAMP_LOG_NETWORK_ERROR (remoteUrl.c_str(), AAMPNetworkErrorHttp, (int)http_code, simType);
                                                print_headerResponse(context.allResponseHeadersForErrorLogging, simType);
 
                                                if((http_code >= 500 && http_code != 502) && downloadAttempt < maxDownloadAttempt)
                                                {
                                                        int waitTimeBeforeRetryHttp5xxMSValue;
                                                        GETCONFIGVALUE_PRIV(eAAMPConfig_Http5XXRetryWaitInterval,waitTimeBeforeRetryHttp5xxMSValue);
                                                        InterruptableMsSleep(waitTimeBeforeRetryHttp5xxMSValue);
                                                        AAMPLOG_WARN("Download failed due to Server error. Retrying Attempt:%d!", downloadAttempt);
                                                        loopAgain = true;
                                                }
                                        }
                                        if(http_code == 204)
                                        {
                                                if ( (httpRespHeaders[curlInstance].type == eHTTPHEADERTYPE_EFF_LOCATION) && (httpRespHeaders[curlInstance].data.length() > 0) )
                                                {
                                                        AAMPLOG_WARN("Received Location header: '%s'", httpRespHeaders[curlInstance].data.c_str());
                                                        effectiveUrlPtr =  const_cast<char *>(httpRespHeaders[curlInstance].data.c_str());
                                                }
                                        }
                                        else
                                        {
                                                //When Fog is having tsb write error , then it will respond back with 302 with direct CDN url,In this case alone TSB should be disabled
                                                if(mTSBEnabled && http_code == 302)
                                                {
                                                        mTSBEnabled = false;
                                                }
                                                res = curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &effectiveUrlPtr);
                                                if((simType == eMEDIATYPE_INIT_VIDEO || simType ==  eMEDIATYPE_INIT_AUDIO))
                                                {
                                                        IsoBmffBuffer isobuf(mLogObj);
                                                        isobuf.setBuffer(reinterpret_cast<uint8_t *>(context.buffer->ptr), context.buffer->len);
 
                                                        bool bParse = false;
                                                        try
                                                        {
                                                                bParse = isobuf.parseBuffer();
                                                        }
                                                        catch( std::bad_alloc& ba)
                                                        {
                                                                AAMPLOG_ERR("Bad allocation: %s", ba.what() );
                                                        }
                                                        catch( std::exception &e)
                                                        {
                                                                AAMPLOG_ERR("Unhandled exception: %s", e.what() );
                                                        }
                                                        catch( ... )
                                                        {
                                                                AAMPLOG_ERR("Unknown exception");
                                                        }
 
                                                        if(!bParse)
                                                        {
                                                                AAMPLOG_ERR("[%d] Cant Find TimeScale. No Box available in Init File !!!", simType);
                                                        }
                                                        else
                                                        {
                                                                AAMPLOG_INFO("[%d] Buffer Length: %zu", simType, context.buffer->len);
 
                                                                //Print box details
                                                                //isobuf.printBoxes();
                                                                if(isobuf.isInitSegment())
                                                                {
                                                                        uint32_t timeScale = 0;
                                                                        isobuf.getTimeScale(timeScale);
                                                                        if(simType == eMEDIATYPE_INIT_VIDEO)
                                                                        {
                                                                                AAMPLOG_INFO("Video TimeScale  [%d]", timeScale);
                                                                                SetVidTimeScale(timeScale);
                                                                        }
                                                                        else
                                                                        {
                                                                                AAMPLOG_INFO("Audio TimeScale  [%d]", timeScale);
                                                                                SetAudTimeScale(timeScale);
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
 
                                        if(effectiveUrlPtr)
                                        {
                                                effectiveUrl.assign(effectiveUrlPtr);    //CID:81493 - Resolve Forward null
 
                                                if( ISCONFIGSET_PRIV(eAAMPConfig_EnableCurlStore) && (remoteUrl!=effectiveUrl) )
                                                {
                                                        curlhost[curlInstance]->redirect = true;
                                                }
                                        }
 
                                        // check if redirected url is pointing to fog / local ip
                                        if(mIsFirstRequestToFOG)
                                        {
                                                if(mTsbRecordingId.empty())
                                                {
                                                        AAMPLOG_INFO("TSB not avaialble from fog, playing from:%s ", effectiveUrl.c_str());
                                                }
                                                this->UpdateVideoEndTsbStatus(mTSBEnabled);
                                        }
 
                                        /*
                                         * Latency should be printed in the case of successful download which exceeds the download threshold value,
                                         * other than this case is assumed as network error and those will be logged with AAMP_LOG_NETWORK_ERROR.
                                         */
                                        if (fragmentDurationSeconds != 0.0)
                                        { 
                                                /*in case of fetch fragment this will be non zero value */
                                                if (downloadTimeMS > fragmentDurationMs )
                                                {
                                                        AAMP_LOG_NETWORK_LATENCY (effectiveUrl.c_str(), downloadTimeMS, fragmentDurationMs, simType);
                                                }
                                        }
                                        else if (downloadTimeMS > FRAGMENT_DOWNLOAD_WARNING_THRESHOLD )
                                        {
                                                AAMP_LOG_NETWORK_LATENCY (effectiveUrl.c_str(), downloadTimeMS, FRAGMENT_DOWNLOAD_WARNING_THRESHOLD, simType);
                                                print_headerResponse(context.allResponseHeadersForErrorLogging, simType);
                                        }
                                }
                                else
                                {
                                        long curlDownloadTimeoutMS = curlDLTimeout[curlInstance]; // curlDLTimeout is in msec
                                        //abortReason for progress_callback exit scenarios
                                        // curl sometimes exceeds the wait time by few milliseconds.Added buffer of 10msec
                                        isDownloadStalled = ((res == CURLE_PARTIAL_FILE) || (progressCtx.abortReason != eCURL_ABORT_REASON_NONE));
                                        // set flag if download aborted with start/stall timeout.
                                        abortReason = progressCtx.abortReason;
 
                                        /* Curl 23 and 42 is not a real network error, so no need to log it here */
                                        //Log errors due to curl stall/start detection abort
                                        if (AAMP_IS_LOG_WORTHY_ERROR(res) || progressCtx.abortReason != eCURL_ABORT_REASON_NONE)
                                        {
                                                AAMP_LOG_NETWORK_ERROR (remoteUrl.c_str(), AAMPNetworkErrorCurl, (int)(progressCtx.abortReason == eCURL_ABORT_REASON_NONE ? res : CURLE_PARTIAL_FILE), simType);
                                                print_headerResponse(context.allResponseHeadersForErrorLogging, simType);
                                        }
 
                                        //Attempt retry for partial downloads, which have a higher chance to succeed
                                        if((res == CURLE_COULDNT_CONNECT || res == CURLE_OPERATION_TIMEDOUT || (isDownloadStalled && (eCURL_ABORT_REASON_LOW_BANDWIDTH_TIMEDOUT != abortReason))) && downloadAttempt < maxDownloadAttempt)
                                        {
                                                if(mpStreamAbstractionAAMP)
                                                {
                                                        if( simType == eMEDIATYPE_MANIFEST ||
                                                                simType == eMEDIATYPE_AUDIO ||
                                                                simType == eMEDIATYPE_VIDEO ||
                                                            simType == eMEDIATYPE_INIT_VIDEO ||
                                                            simType == eMEDIATYPE_PLAYLIST_AUDIO ||
                                                            simType == eMEDIATYPE_INIT_AUDIO ||
                                                                simType == eMEDIATYPE_AUX_AUDIO || simType == eMEDIATYPE_INIT_AUX_AUDIO)
                                                        { // always retry small, critical fragments on timeout
                                                                loopAgain = true;
                                                        }
                                                        else
                                                        {
                                                                double buffervalue = mpStreamAbstractionAAMP->GetBufferedDuration();
                                                                // buffer is -1 when sesssion not created . buffer is 0 when session created but playlist not downloaded
                                                                if( buffervalue == -1.0 || buffervalue == 0 || buffervalue*1000 > (curlDownloadTimeoutMS + fragmentDurationMs))
                                                                {
                                                                        // GetBuffer will return -1 if session is not created
                                                                        // Check if buffer is available and more than timeout interval then only reattempt
                                                                        // Not to retry download if there is no buffer left                                                                     
                                                                        loopAgain = true;
                                                                        if(simType == eMEDIATYPE_VIDEO)
                                                                        {
                                                                                if(buffer->len)
                                                                                {
                                                                                        long downloadbps = ((long)(buffer->len / downloadTimeMS)*8000);
                                                                                        long currentProfilebps  = mpStreamAbstractionAAMP->GetVideoBitrate();
                                                                                        if(currentProfilebps - downloadbps >  BITRATE_ALLOWED_VARIATION_BAND)
                                                                                                loopAgain = false;
                                                                                }
                                                                                curlDownloadTimeoutMS = mNetworkTimeoutMs;      
                                                                        }                                                                                                                                               
                                                                }
                                                        }
                                                }                                               
                                                AAMPLOG_WARN("Download failed due to curl timeout or isDownloadStalled:%d Retrying:%d Attempt:%d", isDownloadStalled, loopAgain, downloadAttempt);
                                        }
 
                                        /*
                                        * Assigning curl error to http_code, for sending the error code as
                                        * part of error event if required
                                        * We can distinguish curl error and http error based on value
                                        * curl errors are below 100 and http error starts from 100
                                        */
                                        if( res == CURLE_FILE_COULDNT_READ_FILE )
                                        {
                                                http_code = 404; // translate file not found to URL not found
                                        }
                                        else if(abortReason == eCURL_ABORT_REASON_LOW_BANDWIDTH_TIMEDOUT)
                                        {
                                                http_code = CURLE_OPERATION_TIMEDOUT; // Timed out wrt configured low bandwidth timeout.
                                        }
                                        else
                                        {
                                                http_code = res;
                                        }
                                        #if 0
                                        if (isDownloadStalled)
                                        {
                                                AAMPLOG_INFO("Curl download stall detected - curl result:%d abortReason:%d downloadTimeMS:%lld curlTimeout:%ld", res, progressCtx.abortReason,
                                                                        downloadTimeMS, curlDownloadTimeoutMS);
                                                //To avoid updateBasedonFragmentCached being called on rampdown and to be discarded from ABR
                                                http_code = CURLE_PARTIAL_FILE;
                                        }
                                        #endif
                                }
                                
 
                                double total, connect, startTransfer, resolve, appConnect, preTransfer, redirect, dlSize;
                                long reqSize, downloadbps = 0;
                                AAMP_LogLevel reqEndLogLevel = eLOGLEVEL_INFO;
                                if(downloadTimeMS != 0 && buffer->len != 0)
                                        downloadbps = ((long)(buffer->len / downloadTimeMS)*8000);
 
                                curl_easy_getinfo(curl, CURLINFO_TOTAL_TIME , &total);
                                curl_easy_getinfo(curl, CURLINFO_CONNECT_TIME, &connect);
                                connectTime = connect;
                                fileDownloadTime = total;
                                if(res != CURLE_OK || http_code == 0 || http_code >= 400 || total > 2.0 /*seconds*/)
                                {
                                        reqEndLogLevel = eLOGLEVEL_WARN;
                                }
                                if (gpGlobalConfig->logging.isLogLevelAllowed(reqEndLogLevel))
                                {
                                        double totalPerformRequest = (double)(downloadTimeMS)/1000;
                                        curl_easy_getinfo(curl, CURLINFO_NAMELOOKUP_TIME, &resolve);
                                        curl_easy_getinfo(curl, CURLINFO_APPCONNECT_TIME, &appConnect);
                                        curl_easy_getinfo(curl, CURLINFO_PRETRANSFER_TIME, &preTransfer);
                                        curl_easy_getinfo(curl, CURLINFO_STARTTRANSFER_TIME, &startTransfer);
                                        curl_easy_getinfo(curl, CURLINFO_REDIRECT_TIME, &redirect);
                                        curl_easy_getinfo(curl, CURLINFO_SIZE_DOWNLOAD, &dlSize);
                                        curl_easy_getinfo(curl, CURLINFO_REQUEST_SIZE, &reqSize);
                                        if((pCMCDMetrics!=NULL) && ISCONFIGSET_PRIV(eAAMPConfig_EnableCMCD))
                                        {
                                                pCMCDMetrics->SetNetworkMetrics((int)(startTransfer*1000),(int)(total*1000),(int)(resolve*1000));
                                        }
 
                                        std::string appName, timeoutClass;
                                        if (!mAppName.empty())
                                        {
                                                // append app name with class data
                                                appName = mAppName + ",";
                                        }
                                        if (CURLE_OPERATION_TIMEDOUT == res || CURLE_PARTIAL_FILE == res || CURLE_COULDNT_CONNECT == res)
                                        {
                                                // introduce  extra marker for connection status curl 7/18/28,
                                                // example 18(0) if connection failure with PARTIAL_FILE code
                                                timeoutClass = "(" + to_string(reqSize > 0) + ")";
                                        }
                                        AAMPLOG(mLogObj, reqEndLogLevel, "WARN", "HttpRequestEnd: %s%d,%d,%d%s,%2.4f,%2.4f,%2.4f,%2.4f,%2.4f,%2.4f,%2.4f,%2.4f,%g,%ld,%ld,%ld,%.500s",
                                                appName.c_str(), mediaType, simType, http_code, timeoutClass.c_str(), totalPerformRequest, total, connect, startTransfer, resolve, appConnect, preTransfer, redirect, dlSize, reqSize,downloadbps,
                                                (((simType == eMEDIATYPE_VIDEO) || (simType == eMEDIATYPE_INIT_VIDEO) || (simType == eMEDIATYPE_PLAYLIST_VIDEO)) ? mpStreamAbstractionAAMP->GetVideoBitrate() : 0), // Video fragment current bitrate
                                                ((res == CURLE_OK) ? effectiveUrl.c_str() : remoteUrl.c_str())); // Effective URL could be different than remoteURL and it is updated only for CURLE_OK case
                                        if(ui32CurlTrace < 10 )
                                        {
                                                AAMPLOG_INFO("%d.CurlTrace:Dns:%2.4f, Conn:%2.4f, Ssl:%2.4f, Redir:%2.4f, Pre:Start[%2.4f:%2.4f], Hdl:%p, Url:%s",
                                                        ui32CurlTrace, resolve, connect, appConnect, redirect, preTransfer, startTransfer, curl,((res==CURLE_OK)?effectiveUrl.c_str():remoteUrl.c_str()));
                                                ++ui32CurlTrace;
                                        }
                                }
 
                                if(!loopAgain)
                                        break;
                        }
                }
 
                if (http_code == 200 || http_code == 206 || http_code == CURLE_OPERATION_TIMEDOUT)
                {
                        if (http_code == CURLE_OPERATION_TIMEDOUT && buffer->len > 0)
                        {
                                AAMPLOG_WARN("Download timedout and obtained a partial buffer of size %zu for a downloadTime=%d and isDownloadStalled:%d", buffer->len, downloadTimeMS, isDownloadStalled);
                        }
 
                        if (downloadTimeMS > 0 && fileType == eMEDIATYPE_VIDEO && CheckABREnabled())
                        {
                                int  AbrThresholdSize;
                                GETCONFIGVALUE_PRIV(eAAMPConfig_ABRThresholdSize,AbrThresholdSize);
                                //HybridABRManager mhABRManager;
                                HybridABRManager::CurlAbortReason hybridabortReason = (HybridABRManager::CurlAbortReason) abortReason;
                                if((buffer->len > AbrThresholdSize) && (!GetLLDashServiceData()->lowLatencyMode ||
                                        ( GetLLDashServiceData()->lowLatencyMode  && ISCONFIGSET_PRIV(eAAMPConfig_DisableLowLatencyABR))))
                                {
                                        long currentProfilebps  = mpStreamAbstractionAAMP->GetVideoBitrate();
                                        long downloadbps = mhAbrManager.CheckAbrThresholdSize(buffer->len,downloadTimeMS,currentProfilebps,fragmentDurationMs,hybridabortReason);
                                                pthread_mutex_lock(&mLock);
                                                mhAbrManager.UpdateABRBitrateDataBasedOnCacheLength(mAbrBitrateData,downloadbps,false);
                                                pthread_mutex_unlock(&mLock);
                                        
                                }
                        }
                }
                if (http_code == 200 || http_code == 206)
                {
                        if((mHarvestCountLimit > 0) && (mHarvestConfig & getHarvestConfigForMedia(fileType)))
                        {
                                /* Avoid chance of overwriting , in case of manifest and playlist, name will be always same */
                                if(fileType == eMEDIATYPE_MANIFEST || fileType == eMEDIATYPE_PLAYLIST_AUDIO 
                                || fileType == eMEDIATYPE_PLAYLIST_IFRAME || fileType == eMEDIATYPE_PLAYLIST_SUBTITLE || fileType == eMEDIATYPE_PLAYLIST_VIDEO )
                                {
                                        mManifestRefreshCount++;
                                }
                                
                                AAMPLOG_WARN("aamp harvestCountLimit: %d mManifestRefreshCount %d", mHarvestCountLimit,mManifestRefreshCount);
                                std::string harvestPath;
                                GETCONFIGVALUE_PRIV(eAAMPConfig_HarvestPath,harvestPath);
                                if(harvestPath.empty() )
                                {
                                        getDefaultHarvestPath(harvestPath);
                                        AAMPLOG_WARN("Harvest path has not configured, taking default path %s", harvestPath.c_str());
                                }
                                if(buffer->ptr)
                                {
                                        if(aamp_WriteFile(remoteUrl, buffer->ptr, buffer->len, fileType, mManifestRefreshCount,harvestPath.c_str()))
                                                mHarvestCountLimit--;
                                }  //CID:168113 - forward null
                        }
                        double expectedContentLength = 0;
                        if ((!context.downloadIsEncoded) && CURLE_OK==curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &expectedContentLength) && ((int)expectedContentLength>0) && ((int)expectedContentLength != (int)buffer->len))
                        {
                                //Note: For non-compressed data, Content-Length header and buffer size should be same. For gzipped data, 'Content-Length' will be <= deflated data.
                                AAMPLOG_WARN("AAMP Content-Length=%d actual=%d", (int)expectedContentLength, (int)buffer->len);
                                http_code       =       416; // Range Not Satisfiable
                                ret             =       false; // redundant, but harmless
                                aamp_Free(buffer);
                                memset(buffer, 0x00, sizeof(*buffer));
                        }
                        else
                        {
                                if(fileType == eMEDIATYPE_MANIFEST)
                                {
                                        fileType = (MediaType)curlInstance;
                                }
                                else if (remoteUrl.find("iframe") != std::string::npos)
                                {
                                        fileType = eMEDIATYPE_IFRAME;
                                }
                                ret = true;
                        }
                }
                else
                {
                        if (AAMP_IS_LOG_WORTHY_ERROR(res))
                        {
                                AAMPLOG_WARN("BAD URL:%s", remoteUrl.c_str());
                        }
                        aamp_Free(buffer);
                        memset(buffer, 0x00, sizeof(*buffer));
 
                        if (rate != 1.0)
                        {
                                fileType = eMEDIATYPE_IFRAME;
                        }
 
                        // dont generate anomaly reports for write and aborted errors
                        // these are generated after trick play options,
                        if( !(http_code == CURLE_ABORTED_BY_CALLBACK || http_code == CURLE_WRITE_ERROR || http_code == 204))
                        {
                                SendAnomalyEvent(ANOMALY_WARNING, "%s:%s,%s-%d url:%s", (mTSBEnabled ? "FOG" : "CDN"),
                                        MediaTypeString(fileType), (http_code < 100) ? "Curl" : "HTTP", http_code, remoteUrl.c_str());
                        }
            
                        if ( (httpRespHeaders[curlInstance].type == eHTTPHEADERTYPE_XREASON) && (httpRespHeaders[curlInstance].data.length() > 0) )
                        {
                                AAMPLOG_WARN("Received X-Reason header from %s: '%s'", mTSBEnabled?"Fog":"CDN Server", httpRespHeaders[curlInstance].data.c_str());
                                SendAnomalyEvent(ANOMALY_WARNING, "%s X-Reason:%s", mTSBEnabled ? "Fog" : "CDN", httpRespHeaders[curlInstance].data.c_str());
                        }
                        else if ( (httpRespHeaders[curlInstance].type == eHTTPHEADERTYPE_FOG_REASON) && (httpRespHeaders[curlInstance].data.length() > 0) )
                        {
                                //extract error and url used by fog to download content from cdn
                                // it is part of fog-reason
                                if(fogError)
                                {
                                        std::regex errRegx("-(.*),");
                                        std::smatch match;
                                        if (std::regex_search(httpRespHeaders[curlInstance].data, match, errRegx) && match.size() > 1) {
                                                if (!match.str(1).empty())
                                                {
                                                        *fogError = std::stoi(match.str(1));
                                                        AAMPLOG_INFO("Received FOG-Reason fogError: '%d'", *fogError);
                                                }
                                        }
                                }
 
                                //      get failed url from fog reason and update effectiveUrl
                                if(!effectiveUrl.empty())
                                {
                                        std::regex fromRegx("from:(.*),");
                                        std::smatch match;
 
                                        if (std::regex_search(httpRespHeaders[curlInstance].data, match, fromRegx) && match.size() > 1) {
                                                if (!match.str(1).empty())
                                                {
                                                        effectiveUrl.assign(match.str(1).c_str());
                                                        AAMPLOG_INFO("Received FOG-Reason effectiveUrl: '%s'", effectiveUrl.c_str());
                                                }
                                        }
                                }
 
 
                AAMPLOG_WARN("Received FOG-Reason header: '%s'", httpRespHeaders[curlInstance].data.c_str());
                SendAnomalyEvent(ANOMALY_WARNING, "FOG-Reason:%s", httpRespHeaders[curlInstance].data.c_str());
            }
                }
 
                if (bitrate && (context.bitrate > 0))
                {
                        AAMPLOG_INFO("Received getfile Bitrate : %ld", context.bitrate);
                        *bitrate = context.bitrate;
                }
 
                if(abortReason != eCURL_ABORT_REASON_NONE && abortReason != eCURL_ABORT_REASON_LOW_BANDWIDTH_TIMEDOUT)
                {
                        http_code = PARTIAL_FILE_START_STALL_TIMEOUT_AAMP;
                }
                else if (connectTime == 0.0)
                {
                        //curl connection is failure
                        if(CURLE_PARTIAL_FILE == http_code)
                        {
                                http_code = PARTIAL_FILE_CONNECTIVITY_AAMP;
                        }
                        else if(CURLE_OPERATION_TIMEDOUT == http_code)
                        {
                                http_code = OPERATION_TIMEOUT_CONNECTIVITY_AAMP;
                        }
                }
                else if (CURLE_PARTIAL_FILE == http_code)
                {
                        // download time expired with partial file for playlists/init fragments
                        http_code = PARTIAL_FILE_DOWNLOAD_TIME_EXPIRED_AAMP;
                }
                pthread_mutex_lock(&mLock);
        }
        else
        {
                AAMPLOG_WARN("downloads disabled");
        }
        pthread_mutex_unlock(&mLock);
        if (http_error)
        {
                *http_error = http_code;
                if(downloadTime)
                {
                        *downloadTime = fileDownloadTime;
                }
        }
        if (httpHeaders != NULL)
        {
                curl_slist_free_all(httpHeaders);
        }
        if (mIsFirstRequestToFOG)
        {
                mIsFirstRequestToFOG = false;
        }
 
    if (ISCONFIGSET_PRIV(eAAMPConfig_EnableLinearSimulator))
        {
                // NEW! note that for simulated playlists, ideally we'd not bother re-downloading playlist above
 
                AAMPLOG_INFO("*** Simulated Linear URL: %s\n", remoteUrl.c_str()); // Log incoming request
 
                switch( simType )
                {
                        case eMEDIATYPE_MANIFEST:
                        {
                                // Reset state after requesting main manifest
                                if( full_playlist_video_ptr )
                                {
                                        // Flush old cached video playlist
 
                                        free( full_playlist_video_ptr );
                                        full_playlist_video_ptr = NULL;
                                        full_playlist_video_len = 0;
                                }
 
                                if( full_playlist_audio_ptr )
                                {
                                        // Flush old cached audio playlist
 
                                        free( full_playlist_audio_ptr );
                                        full_playlist_audio_ptr = NULL;
                                        full_playlist_audio_len = 0;
                                }
 
                                simulation_start = aamp_GetCurrentTimeMS();
                        }
                                break; /* eMEDIATYPE_MANIFEST */
 
                        case eMEDIATYPE_PLAYLIST_AUDIO:
                        {
                                if( !full_playlist_audio_ptr )
                                {
                                        // Cache the full vod audio playlist
 
                                        full_playlist_audio_len = buffer->len;
                                        full_playlist_audio_ptr = (char *)malloc(buffer->len);
                                        memcpy( full_playlist_audio_ptr, buffer->ptr, buffer->len );
                                }
 
                                SimulateLinearWindow( buffer, full_playlist_audio_ptr, full_playlist_audio_len );
                        }
                                break; /* eMEDIATYPE_PLAYLIST_AUDIO */
 
                        case eMEDIATYPE_PLAYLIST_VIDEO:
                        {
                                if( !full_playlist_video_ptr )
                                {
                                        // Cache the full vod video playlist
 
                                        full_playlist_video_len = buffer->len;
                                        full_playlist_video_ptr = (char *)malloc(buffer->len);
                                        memcpy( full_playlist_video_ptr, buffer->ptr, buffer->len );
                                }
 
                                SimulateLinearWindow( buffer, full_playlist_video_ptr, full_playlist_video_len );
                        }
                                break; /* eMEDIATYPE_PLAYLIST_VIDEO */
 
                        default:
                                break;
                }
        }
        //Stip downloaded chunked Iframes when ranged requests receives 200 as HTTP response for HLS MP4
        if(  mConfig->IsConfigSet(eAAMPConfig_RepairIframes) && NULL != range && '\0' != range[0] && 200 == http_code && NULL != buffer->ptr && FORMAT_ISO_BMFF == this->mVideoFormat)
        {
                AAMPLOG_INFO( "Received HTTP 200 for ranged request (chunked iframe: %s: %s), starting to strip the fragment", range, remoteUrl.c_str() );
                size_t start;
                size_t end;
                try {
                        if(2 == sscanf(range, "%zu-%zu", &start, &end))
                        {
                                // #EXT-X-BYTERANGE:19301@88 from manifest is equivalent to 88-19388 in HTTP range request
                                size_t len = (end - start) + 1;
                                if( buffer->len >= len)
                                {       
                                        memmove(buffer->ptr, buffer->ptr + start, len);
                                        buffer->len=len;
                                }
                        
                                // hack - repair wrong size in box
                                IsoBmffBuffer repair(mLogObj);
                                repair.setBuffer((uint8_t *)buffer->ptr, buffer->len);
                                repair.parseBuffer(true);  //correctBoxSize=true
                                AAMPLOG_INFO("Stripping the fragment for range request completed");
                        }
                        else
                        {
                                AAMPLOG_ERR("Stripping the fragment for range request failed, failed to parse range string");
                        }
                }
                catch (std::exception &e)
                {
                                AAMPLOG_ERR("Stripping the fragment for ranged request failed (%s)", e.what());
                }
        }
 
        return ret;
}
 
/**
 * @brief Download VideoEnd Session statistics from fog
 *
 * @return string tsbSessionEnd data from fog
 */
char * PrivateInstanceAAMP::GetOnVideoEndSessionStatData()
{
        std::string remoteUrl = "127.0.0.1:9080/sessionstat";
        long http_error = -1;
        char* ret = NULL;
        if(!mTsbRecordingId.empty())
        {
                /* Request session statistics for current recording ID
                 *
                 * example request: 127.0.0.1:9080/sessionstat/<recordingID>
                 *
                 */
                remoteUrl.append("/");
                remoteUrl.append(mTsbRecordingId);
                GrowableBuffer data;
                if(ProcessCustomCurlRequest(remoteUrl, &data, &http_error))
                {
                        // succesfully requested
                        AAMPLOG_INFO("curl request %s success", remoteUrl.c_str());
                        cJSON *root = cJSON_Parse(data.ptr);
                        if (root == NULL)
                        {
                                const char *error_ptr = cJSON_GetErrorPtr();
                                if (error_ptr != NULL)
                                {
                                        AAMPLOG_ERR("Invalid Json format: %s", error_ptr);
                                }
                        }
                        else
                        {
                                ret = cJSON_PrintUnformatted(root);
                                cJSON_Delete(root);
                        }
 
                }
                else
                {
                        // Failure in request
                        AAMPLOG_ERR("curl request %s failed[%d]", remoteUrl.c_str(), http_error);
                }
 
                aamp_Free(&data);
        }
 
        return ret;
}
 
/**
 * @brief Perform custom curl request
 */
bool PrivateInstanceAAMP::ProcessCustomCurlRequest(std::string& remoteUrl, GrowableBuffer* buffer, long *http_error, CurlRequest request, std::string pData)
{
        bool ret = false;
        CURLcode res;
        long httpCode = -1;
        CURL *curl = curl_easy_init();
        if(curl)
        {
                AAMPLOG_INFO("%s, %d", remoteUrl.c_str(), request);
                                
                CURL_EASY_SETOPT(curl, CURLOPT_TIMEOUT, DEFAULT_CURL_TIMEOUT);
                CURL_EASY_SETOPT(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_WHATEVER);
                CURL_EASY_SETOPT(curl, CURLOPT_FOLLOWLOCATION, 1L);
 
                if(!ISCONFIGSET_PRIV(eAAMPConfig_SslVerifyPeer))
                {
                        CURL_EASY_SETOPT(curl, CURLOPT_SSL_VERIFYPEER, 0L);
                }
                else
                {
                        CURL_EASY_SETOPT(curl, CURLOPT_SSLVERSION, mSupportedTLSVersion);
                        CURL_EASY_SETOPT(curl, CURLOPT_SSL_VERIFYPEER, 1L);
                }
                CURL_EASY_SETOPT(curl, CURLOPT_URL, remoteUrl.c_str());
 
                if(eCURL_GET == request)
                {
                        CurlCallbackContext context(this, buffer);
                        memset(buffer, 0x00, sizeof(*buffer));
                        CurlProgressCbContext progressCtx(this, NOW_STEADY_TS_MS);
 
                        CURL_EASY_SETOPT(curl, CURLOPT_NOSIGNAL, 1L);
                        CURL_EASY_SETOPT(curl, CURLOPT_WRITEFUNCTION, write_callback);
                        CURL_EASY_SETOPT(curl, CURLOPT_PROGRESSFUNCTION, progress_callback);
                        CURL_EASY_SETOPT(curl, CURLOPT_PROGRESSDATA, &progressCtx);
                        CURL_EASY_SETOPT(curl, CURLOPT_NOPROGRESS, 0L);
                        CURL_EASY_SETOPT(curl, CURLOPT_WRITEDATA, &context);
                        CURL_EASY_SETOPT(curl, CURLOPT_HTTPGET, 1L);
                        res = curl_easy_perform(curl); // DELIA-57728 - avoid out of scope use of progressCtx
                }
                else if(eCURL_DELETE == request)
                {
                        CURL_EASY_SETOPT(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
                        res = curl_easy_perform(curl);
                }
                else if(eCURL_POST == request)
                {
                        CURL_EASY_SETOPT(curl, CURLOPT_POSTFIELDSIZE, pData.size());
                        CURL_EASY_SETOPT(curl, CURLOPT_POSTFIELDS,(uint8_t * )pData.c_str());
                        res = curl_easy_perform(curl);
                }
 
                if (res == CURLE_OK)
                {
                        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpCode);
                        if ((httpCode == 204) || (httpCode == 200))
                        {
                                ret = true;
                        }
                        else
                        {
                                AAMPLOG_ERR("Returned [%d]", httpCode);
                        }
                }
                else
                {
                        AAMPLOG_ERR("Failed to perform curl request, result:%d", res);
                }
 
                if(httpCode > 0)
                {
                        *http_error = httpCode;
                }
 
                curl_easy_cleanup(curl);
        }
        return ret;
}
 
/**
 * @brief Terminate the stream
 */
void PrivateInstanceAAMP::TeardownStream(bool newTune)
{
        pthread_mutex_lock(&mLock);
        //Have to perfom this for trick and stop operations but avoid ad insertion related ones
        AAMPLOG_WARN(" mProgressReportFromProcessDiscontinuity:%d mDiscontinuityTuneOperationId:%d newTune:%d", mProgressReportFromProcessDiscontinuity, mDiscontinuityTuneOperationId, newTune);
        if ((mDiscontinuityTuneOperationId != 0) && (!newTune || mState == eSTATE_IDLE))
        {
                bool waitForDiscontinuityProcessing = true;
                if (mProgressReportFromProcessDiscontinuity)
                {
                        AAMPLOG_WARN("TeardownStream invoked while mProgressReportFromProcessDiscontinuity and mDiscontinuityTuneOperationId[%d] set!", mDiscontinuityTuneOperationId);
                        guint callbackID = aamp_GetSourceID();
                        if ((callbackID != 0 && mDiscontinuityTuneOperationId == callbackID) || mAsyncTuneEnabled)
                        {
                                AAMPLOG_WARN("TeardownStream idle callback id[%d] and mDiscontinuityTuneOperationId[%d] match. Ignore further discontinuity processing!", callbackID, mDiscontinuityTuneOperationId);
                                waitForDiscontinuityProcessing = false; // to avoid deadlock
                                mDiscontinuityTuneOperationInProgress = false;
                                mDiscontinuityTuneOperationId = 0;
                        }
                }
                if (waitForDiscontinuityProcessing)
                {
                        //wait for discontinuity tune operation to finish before proceeding with stop
                        if (mDiscontinuityTuneOperationInProgress)
                        {
                                AAMPLOG_WARN("TeardownStream invoked while mDiscontinuityTuneOperationInProgress set. Wait until the Discontinuity Tune operation to complete!!");
                                pthread_cond_wait(&mCondDiscontinuity, &mLock);
                        }
                        else
                        {
                                RemoveAsyncTask(mDiscontinuityTuneOperationId);
                                mDiscontinuityTuneOperationId = 0;
                        }
                }
        }
        // Maybe mDiscontinuityTuneOperationId is 0, ProcessPendingDiscontinuity can be invoked from NotifyEOSReached too
        else if (mProgressReportFromProcessDiscontinuity || mDiscontinuityTuneOperationInProgress)
        {
                if(mDiscontinuityTuneOperationInProgress)
                {
                        AAMPLOG_WARN("TeardownStream invoked while mDiscontinuityTuneOperationInProgress set. Wait until the pending discontinuity tune operation to complete !!");
                        pthread_cond_wait(&mCondDiscontinuity, &mLock);
                }
                else
                {
                        AAMPLOG_WARN("TeardownStream invoked while mProgressReportFromProcessDiscontinuity set!");
                        mDiscontinuityTuneOperationInProgress = false;
                }
        }
 
        //reset discontinuity related flags
        ResetDiscontinuityInTracks();
        UnblockWaitForDiscontinuityProcessToComplete();
        ResetTrackDiscontinuityIgnoredStatus();
        pthread_mutex_unlock(&mLock);
 
        if (mpStreamAbstractionAAMP)
        {
                mpStreamAbstractionAAMP->Stop(false);
                SAFE_DELETE(mpStreamAbstractionAAMP);
        }
 
        pthread_mutex_lock(&mLock);
        mVideoFormat = FORMAT_INVALID;
        pthread_mutex_unlock(&mLock);
        if (streamerIsActive)
        {
#ifdef AAMP_STOP_SINK_ON_SEEK
                const bool forceStop = true;
                // Don't send event if nativeCCRendering is ON
                if (!ISCONFIGSET_PRIV(eAAMPConfig_NativeCCRendering))
                {
                        CCHandleEventPtr event = std::make_shared<CCHandleEvent>(0);
                        mEventManager->SendEvent(event);
                        AAMPLOG_WARN("Sent AAMP_EVENT_CC_HANDLE_RECEIVED with NULL handle");
                }
#else
                const bool forceStop = false;
#endif
                if (!forceStop && ((!newTune && ISCONFIGSET_PRIV(eAAMPConfig_DemuxVideoHLSTrack)) || ISCONFIGSET_PRIV(eAAMPConfig_PreservePipeline)))
                {
                        mStreamSink->Flush(0, rate);
                }
                else
                {
#ifdef AAMP_CC_ENABLED
                        AAMPLOG_INFO("before CC Release - mTuneType:%d mbPlayEnabled:%d ", mTuneType, mbPlayEnabled);
                        if (mbPlayEnabled && mTuneType != eTUNETYPE_RETUNE)
                        {
                                AampCCManager::GetInstance()->Release(mCCId);
                                mCCId = 0;
                        }
                        else
                        {
                                AAMPLOG_WARN("CC Release - skipped ");
                        }
#endif
                        if(!mbUsingExternalPlayer)
                        {
                                mStreamSink->Stop(!newTune);
                        }
                }
        }
        else
        {
                for (int iTrack = 0; iTrack < AAMP_TRACK_COUNT; iTrack++)
                {
                        mbTrackDownloadsBlocked[iTrack] = true;
                }
                streamerIsActive = true;
        }
        mAdProgressId = "";
        std::queue<AAMPEventPtr> emptyEvQ;
        {
                std::lock_guard<std::mutex> lock(mAdEventQMtx);
                std::swap( mAdEventsQ, emptyEvQ );
        }
}
 
/**
 * @brief Establish PIPE session with Receiver
 */
bool PrivateInstanceAAMP::SetupPipeSession()
{
        bool retVal = false;
        if(m_fd != -1)
        {
                retVal = true; //Pipe exists
                return retVal;
        }
        if(mkfifo(strAAMPPipeName, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) == -1)
        {
                if(errno == EEXIST)
                {
                        // Pipe exists
                        //AAMPLOG_WARN("CreatePipe: Pipe already exists");
                        retVal = true;
                }
                else
                {
                        // Error
                        AAMPLOG_ERR("CreatePipe: Failed to create named pipe %s for reading errno = %d (%s)",
                                strAAMPPipeName, errno, strerror(errno));
                }
        }
        else
        {
                // Success
                //AAMPLOG_WARN("CreatePipe: mkfifo succeeded");
                retVal = true;
        }
 
        if(retVal)
        {
                // Open the named pipe for writing
                m_fd = open(strAAMPPipeName, O_WRONLY | O_NONBLOCK  );
                if (m_fd == -1)
                {
                        // error
                        AAMPLOG_WARN("OpenPipe: Failed to open named pipe %s for writing errno = %d (%s)",
                                strAAMPPipeName, errno, strerror(errno));
                }
                else
                {
                        // Success
                        retVal = true;
                }
        }
        return retVal;
}
 
 
/**
 * @brief Close PIPE session with Receiver
 */
void PrivateInstanceAAMP::ClosePipeSession()
{
        if(m_fd != -1)
        {
                close(m_fd);
                m_fd = -1;
        }
}
                            
/**
 * @brief Send messages to Receiver over PIPE
 */
void PrivateInstanceAAMP::SendMessageOverPipe(const char *str,int nToWrite)
{
        if(m_fd != -1)
        {
                // Write the packet data to the pipe
                int nWritten =  write(m_fd, str, nToWrite);
                if(nWritten != nToWrite)
                {
                        // Error
                        AAMPLOG_WARN("Error writing data written = %d, size = %d errno = %d (%s)",
                                nWritten, nToWrite, errno, strerror(errno));
                        if(errno == EPIPE)
                        {
                                // broken pipe, lets reset and open again when the pipe is avail
                                ClosePipeSession();
                        }
                }
        }
}
 
/**
 * @brief Send message to reciever over PIPE
 */
void PrivateInstanceAAMP::SendMessage2Receiver(AAMP2ReceiverMsgType type, const char *data)
{
#ifdef CREATE_PIPE_SESSION_TO_XRE
        if(SetupPipeSession())
        {
                int dataLen = strlen(data);
                int sizeToSend = AAMP2ReceiverMsgHdrSz + dataLen;
                std::vector<uint8_t> tmp(sizeToSend,0);
                AAMP2ReceiverMsg *msg = (AAMP2ReceiverMsg *)(tmp.data());
                msg->type = (unsigned int)type;
                msg->length = dataLen;
                memcpy(msg->data, data, dataLen);
                SendMessageOverPipe((char *)tmp.data(), sizeToSend);
        }
#else
        AAMPLOG_INFO("AAMP=>XRE: %s",data);
#endif
}
 
/**
 * @brief The helper function which perform tuning
 * Common tune operations used on Tune, Seek, SetRate etc
 */
void PrivateInstanceAAMP::TuneHelper(TuneType tuneType, bool seekWhilePaused)
{
        bool newTune;
        for (int i = 0; i < AAMP_TRACK_COUNT; i++)
        {
                lastUnderFlowTimeMs[i] = 0;
        }
        pthread_mutex_lock(&mFragmentCachingLock);
        mFragmentCachingRequired = false;
        mPauseOnFirstVideoFrameDisp = false;
        mFirstVideoFrameDisplayedEnabled = false;
        pthread_mutex_unlock(&mFragmentCachingLock);
 
        if( seekWhilePaused )
        { // XIONE-4261 Player state not updated correctly after seek
                // Prevent gstreamer callbacks from placing us back into playing state by setting these gate flags before CBs are triggered
                // in this routine. See NotifyFirstFrameReceived(), NotifyFirstBufferProcessed(), NotifyFirstVideoFrameDisplayed()
                mPauseOnFirstVideoFrameDisp = true;
                mFirstVideoFrameDisplayedEnabled = true;
        }
 
 
        if (tuneType == eTUNETYPE_SEEK || tuneType == eTUNETYPE_SEEKTOLIVE || tuneType == eTUNETYPE_SEEKTOEND)
        {
                mSeekOperationInProgress = true;
        }
 
        if (eTUNETYPE_LAST == tuneType)
        {
                tuneType = mTuneType;
        }
        else
        {
                mTuneType = tuneType;
        }
 
        newTune = IsNewTune();
 
        // DELIA-39530 - Get position before pipeline is teared down
        if (eTUNETYPE_RETUNE == tuneType)
        {
                seek_pos_seconds = GetPositionSeconds();
        }
        else
        {
                //Only trigger the clear to encrypted pipeline switch while on retune
                mEncryptedPeriodFound = false;
                mPipelineIsClear = false;
                AAMPLOG_INFO ("Resetting mClearPipeline & mEncryptedPeriodFound");
        }
 
        TeardownStream(newTune|| (eTUNETYPE_RETUNE == tuneType));
 
#if defined(AMLOGIC)
        // Send new SEGMENT event only on all trickplay and trickplay -> play, not on pause -> play / seek while paused
        // this shouldn't impact seekplay or ADs on Peacock & LLAMA
        if (tuneType == eTUNETYPE_SEEK && !(mbSeeked == true || rate == 0 || (rate == 1 && pipeline_paused == true)))
                for (int i = 0; i < AAMP_TRACK_COUNT; i++) mbNewSegmentEvtSent[i] = false;
#endif
 
        ui32CurlTrace=0;
 
        if (newTune)
        {
 
                // send previouse tune VideoEnd Metrics data
                // this is done here because events are cleared on stop and there is chance that event may not get sent
                // check for mEnableVideoEndEvent and call SendVideoEndEvent ,object mVideoEnd is created inside SendVideoEndEvent
                if(mTuneAttempts == 1) // only for first attempt, dont send event when JSPP retunes.
                {
                        SendVideoEndEvent();
                }
 
                mTsbRecordingId.clear();
                // initialize defaults
                SetState(eSTATE_INITIALIZING);
                culledSeconds = 0;
                durationSeconds = 60 * 60; // 1 hour
                rate = AAMP_NORMAL_PLAY_RATE;
                StoreLanguageList(std::set<std::string>());
                mTunedEventPending = true;
                mProfileCappedStatus = false;
#ifdef USE_OPENCDM
                AampOutputProtection *pInstance = AampOutputProtection::GetAampOutputProcectionInstance();
                pInstance->GetDisplayResolution(mDisplayWidth, mDisplayHeight);
                pInstance->Release();
#endif
                AAMPLOG_INFO ("Display Resolution width:%d height:%d", mDisplayWidth, mDisplayHeight);
 
                mOrigManifestUrl.hostname = aamp_getHostFromURL(mManifestUrl);
                mOrigManifestUrl.isRemotehost = !(aamp_IsLocalHost(mOrigManifestUrl.hostname));
                AAMPLOG_TRACE("CurlTrace OrigManifest url:%s", mOrigManifestUrl.hostname.c_str());
        }
 
        trickStartUTCMS = -1;
 
        double playlistSeekPos = seek_pos_seconds - culledSeconds;
        AAMPLOG_INFO("playlistSeek : %f seek_pos_seconds:%f culledSeconds : %f ",playlistSeekPos,seek_pos_seconds,culledSeconds);
        if (playlistSeekPos < 0)
        {
                playlistSeekPos = 0;
                seek_pos_seconds = culledSeconds;
                AAMPLOG_WARN("Updated seek_pos_seconds %f ", seek_pos_seconds);
        }
        
        if (mMediaFormat == eMEDIAFORMAT_DASH)
        {
                #if defined (INTELCE)
                AAMPLOG_WARN("Error: Dash playback not available");
                mInitSuccess = false;
                SendErrorEvent(AAMP_TUNE_UNSUPPORTED_STREAM_TYPE);
                return;
                #else
                mpStreamAbstractionAAMP = new StreamAbstractionAAMP_MPD(mLogObj,this, playlistSeekPos, rate);
                if (NULL == mCdaiObject)
                {
                        mCdaiObject = new CDAIObjectMPD(mLogObj, this); // special version for DASH
                }
                #endif
        }
        else if (mMediaFormat == eMEDIAFORMAT_HLS || mMediaFormat == eMEDIAFORMAT_HLS_MP4)
        { // m3u8
                mpStreamAbstractionAAMP = new StreamAbstractionAAMP_HLS(mLogObj,this, playlistSeekPos, rate);
                if(NULL == mCdaiObject)
                {
                        mCdaiObject = new CDAIObject(mLogObj, this);    //Placeholder to reject the SetAlternateContents()
                }
        }
        else if (mMediaFormat == eMEDIAFORMAT_PROGRESSIVE)
        {
                mpStreamAbstractionAAMP = new StreamAbstractionAAMP_PROGRESSIVE(mLogObj,this, playlistSeekPos, rate);
                if (NULL == mCdaiObject)
                {
                        mCdaiObject = new CDAIObject(mLogObj, this);    //Placeholder to reject the SetAlternateContents()
                }
                // Set to false so that EOS events can be sent. Flag value was whatever previous asset had set it to.
                SetIsLive(false);
        }
        else if (mMediaFormat == eMEDIAFORMAT_HDMI)
        {
                mpStreamAbstractionAAMP = new StreamAbstractionAAMP_HDMIIN(mLogObj,this, playlistSeekPos, rate);
                if (NULL == mCdaiObject)
                {
                        mCdaiObject = new CDAIObject(mLogObj, this);    //Placeholder to reject the SetAlternateContents()
                }
        }
        else if (mMediaFormat == eMEDIAFORMAT_OTA)
        {
                mpStreamAbstractionAAMP = new StreamAbstractionAAMP_OTA(mLogObj,this, playlistSeekPos, rate);
                if (NULL == mCdaiObject)
                {
                        mCdaiObject = new CDAIObject(mLogObj, this);    //Placeholder to reject the SetAlternateContents()
                }
        }
#ifdef USE_CPP_THUNDER_PLUGIN_ACCESS
        else if (mMediaFormat == eMEDIAFORMAT_RMF)
        {
                mpStreamAbstractionAAMP = new StreamAbstractionAAMP_RMF(mLogObj,this, playlistSeekPos, rate);
                if (NULL == mCdaiObject)
                {
                        mCdaiObject = new CDAIObject(mLogObj, this);    //Placeholder to reject the SetAlternateContents()
                }
        }
#endif //USE_CPP_THUNDER_PLUGIN_ACCESS
        else if (mMediaFormat == eMEDIAFORMAT_COMPOSITE)
        {
                mpStreamAbstractionAAMP = new StreamAbstractionAAMP_COMPOSITEIN(mLogObj,this, playlistSeekPos, rate);
                if (NULL == mCdaiObject)
                {
                        mCdaiObject = new CDAIObject(mLogObj, this);    //Placeholder to reject the SetAlternateContents()
                }
        }
        else if (mMediaFormat == eMEDIAFORMAT_SMOOTHSTREAMINGMEDIA)
        {
                AAMPLOG_ERR("Error: SmoothStreamingMedia playback not supported");
                mInitSuccess = false;
                SendErrorEvent(AAMP_TUNE_UNSUPPORTED_STREAM_TYPE);
                return;
        }
 
        mInitSuccess = true;
        AAMPStatusType retVal;
        if (mpStreamAbstractionAAMP)
        {
                mpStreamAbstractionAAMP->SetCDAIObject(mCdaiObject);
                retVal = mpStreamAbstractionAAMP->Init(tuneType);
        }
        else
        {
                retVal = eAAMPSTATUS_GENERIC_ERROR;
        }
 
        // Validate tune type
        // (need to find a better way to do this)
        if (tuneType == eTUNETYPE_NEW_NORMAL) // either no offset (mIsDefaultOffset = true) or -1 was specified
        {
                if(!IsLive() && !mIsDefaultOffset)
                {
                        if (mMediaFormat == eMEDIAFORMAT_DASH) //curently only supported for dash
                        {
                                tuneType = eTUNETYPE_NEW_END;
                        }
                }
        }
        mIsDefaultOffset = false;
 
        if ((tuneType == eTUNETYPE_NEW_END) ||
            (tuneType == eTUNETYPE_SEEKTOEND))
        {
                if (mMediaFormat != eMEDIAFORMAT_DASH)
                {
                        AAMPLOG_WARN("PrivateInstanceAAMP: tune to end not supported for format");
                        retVal = eAAMPSTATUS_GENERIC_ERROR;
                }
        }
 
        if (retVal != eAAMPSTATUS_OK)
        {
                // Check if the seek position is beyond the duration
                if(retVal == eAAMPSTATUS_SEEK_RANGE_ERROR)
                {
                        AAMPLOG_WARN("mpStreamAbstractionAAMP Init Failed.Seek Position(%f) out of range(%lld)",mpStreamAbstractionAAMP->GetStreamPosition(),(GetDurationMs()/1000));
                        NotifyEOSReached();
                }
                else if(mIsFakeTune)
                {
                        if(retVal == eAAMPSTATUS_FAKE_TUNE_COMPLETE)
                        {
                                AAMPLOG(mLogObj, eLOGLEVEL_FATAL, "FATAL", "Fake tune completed");
                        }
                        else
                        {
                                SetState(eSTATE_COMPLETE);
                                mEventManager->SendEvent(std::make_shared<AAMPEventObject>(AAMP_EVENT_EOS));
                                AAMPLOG(mLogObj, eLOGLEVEL_FATAL, "FATAL", "Stopping fake tune playback");
                        }
                }
                else if (DownloadsAreEnabled())
                {
                        AAMPLOG_ERR("mpStreamAbstractionAAMP Init Failed.Error(%d)",retVal);
                        AAMPTuneFailure failReason = AAMP_TUNE_INIT_FAILED;
                        switch(retVal)
                        {
                        case eAAMPSTATUS_MANIFEST_DOWNLOAD_ERROR:
                                failReason = AAMP_TUNE_INIT_FAILED_MANIFEST_DNLD_ERROR; break;
                        case eAAMPSTATUS_PLAYLIST_VIDEO_DOWNLOAD_ERROR:
                                failReason = AAMP_TUNE_INIT_FAILED_PLAYLIST_VIDEO_DNLD_ERROR; break;
                        case eAAMPSTATUS_PLAYLIST_AUDIO_DOWNLOAD_ERROR:
                                failReason = AAMP_TUNE_INIT_FAILED_PLAYLIST_AUDIO_DNLD_ERROR; break;
                        case eAAMPSTATUS_MANIFEST_CONTENT_ERROR:
                                failReason = AAMP_TUNE_INIT_FAILED_MANIFEST_CONTENT_ERROR; break;
                        case eAAMPSTATUS_MANIFEST_PARSE_ERROR:
                                failReason = AAMP_TUNE_INIT_FAILED_MANIFEST_PARSE_ERROR; break;
                        case eAAMPSTATUS_TRACKS_SYNCHRONISATION_ERROR:
                        case eAAMPSTATUS_INVALID_PLAYLIST_ERROR:
                                failReason = AAMP_TUNE_INIT_FAILED_TRACK_SYNC_ERROR; break;
                        case eAAMPSTATUS_UNSUPPORTED_DRM_ERROR:
                                failReason = AAMP_TUNE_DRM_UNSUPPORTED; break;
                        default :
                                break;
                        }
 
                        if (failReason == AAMP_TUNE_INIT_FAILED_PLAYLIST_VIDEO_DNLD_ERROR || failReason == AAMP_TUNE_INIT_FAILED_PLAYLIST_AUDIO_DNLD_ERROR)
                        {
                                long http_error = mPlaylistFetchFailError;
                                SendDownloadErrorEvent(failReason, http_error);
                        }
                        else
                        {
                                SendErrorEvent(failReason);
                        }
                }
                mInitSuccess = false;
                return;
        }
        else
        {
                // LLAMA-7124 - explicitly invalidate previous position for consistency with previous code
                mPrevPositionMilliseconds.Invalidate();
 
                int volume = audio_volume;
                double updatedSeekPosition = mpStreamAbstractionAAMP->GetStreamPosition();
                seek_pos_seconds = updatedSeekPosition + culledSeconds;
                // Adjust seek_pos_second based on adjusted stream position and discontinuity start time for absolute progress reports
                if(ISCONFIGSET_PRIV(eAAMPConfig_UseAbsoluteTimeline) && !ISCONFIGSET_PRIV(eAAMPConfig_MidFragmentSeek) && !IsUninterruptedTSB())
                {
                        double startTimeOfDiscontinuity = mpStreamAbstractionAAMP->GetStartTimeOfFirstPTS() / 1000;
                        if(startTimeOfDiscontinuity > 0)
                        {
                                seek_pos_seconds = startTimeOfDiscontinuity + updatedSeekPosition;
                                if(!IsLive())
                                {
                                        // For dynamic => static cases, add culled seconds
                                        // For normal VOD, culledSeconds is expected to be 0.
                                        seek_pos_seconds += culledSeconds;
                                }
                                AAMPLOG_WARN("Position adjusted discontinuity start: %lf, Abs position: %lf", startTimeOfDiscontinuity, seek_pos_seconds);
                        }
                }
                culledOffset = culledSeconds;
                UpdateProfileCappedStatus();
#ifndef AAMP_STOP_SINK_ON_SEEK
                AAMPLOG_WARN("Updated seek_pos_seconds %f culledSeconds :%f", seek_pos_seconds,culledSeconds);
#endif
                mpStreamAbstractionAAMP->GetStreamFormat(mVideoFormat, mAudioFormat, mAuxFormat, mSubtitleFormat);
                AAMPLOG_INFO("TuneHelper : mVideoFormat %d, mAudioFormat %d mAuxFormat %d", mVideoFormat, mAudioFormat, mAuxFormat);
 
                //Identify if HLS with mp4 fragments, to change media format
                if (mVideoFormat == FORMAT_ISO_BMFF && mMediaFormat == eMEDIAFORMAT_HLS)
                {
                        mMediaFormat = eMEDIAFORMAT_HLS_MP4;
                }
 
                // Enable fragment initial caching. Retune not supported
                if(tuneType != eTUNETYPE_RETUNE
                        && GetInitialBufferDuration() > 0
                        && rate == AAMP_NORMAL_PLAY_RATE
                        && mpStreamAbstractionAAMP->IsInitialCachingSupported())
                {
                        mFirstVideoFrameDisplayedEnabled = true;
                        mFragmentCachingRequired = true;
                }
 
                // Set Pause on First Video frame if seeking and requested
                if( mSeekOperationInProgress && seekWhilePaused )
                {
                        mFirstVideoFrameDisplayedEnabled = true;
                        mPauseOnFirstVideoFrameDisp = true;
                }
 
#ifndef AAMP_STOP_SINK_ON_SEEK
                if (mMediaFormat == eMEDIAFORMAT_HLS)
                {
                        //Live adjust or syncTrack occurred, sent an updated flush event
                        if ((!newTune && ISCONFIGSET_PRIV(eAAMPConfig_DemuxVideoHLSTrack)) || ISCONFIGSET_PRIV(eAAMPConfig_PreservePipeline))
                        {
                                mStreamSink->Flush(mpStreamAbstractionAAMP->GetFirstPTS(), rate);
                        }
                }
                else if (mMediaFormat == eMEDIAFORMAT_DASH)
                {
                        /*
                        commenting the Flush call with updatedSeekPosition as a work around for
                        Trick play freeze issues observed for rogers cDVR content (MBTROGERS-838)
                        @TODO Need to investigate and identify proper way to send Flush and segment 
                        events to avoid the freeze  
                        if (!(newTune || (eTUNETYPE_RETUNE == tuneType)) && !IsTSBSupported())
                        {
                                mStreamSink->Flush(updatedSeekPosition, rate);
                        }
                        else
                        {
                                mStreamSink->Flush(0, rate);
                        }
                        */
                        mStreamSink->Flush(mpStreamAbstractionAAMP->GetFirstPTS(), rate);
                }
                else if (mMediaFormat == eMEDIAFORMAT_PROGRESSIVE)
                {
                        mStreamSink->Flush(updatedSeekPosition, rate);
                        // ff trick mode, mp4 content is single file and muted audio to avoid glitch
                        if (rate > AAMP_NORMAL_PLAY_RATE)
                        {
                                volume = 0;
                        }
                        // reset seek_pos after updating playback start, since mp4 content provide absolute position value
                        seek_pos_seconds = 0;
                }
#endif
                if (!mbUsingExternalPlayer)
                {
                        mStreamSink->SetVideoZoom(zoom_mode);
                        mStreamSink->SetVideoMute(video_muted);
                        mStreamSink->SetAudioVolume(volume);
                        if (mbPlayEnabled)
                        {
                                mStreamSink->Configure(mVideoFormat, mAudioFormat, mAuxFormat, mSubtitleFormat, mpStreamAbstractionAAMP->GetESChangeStatus(), mpStreamAbstractionAAMP->GetAudioFwdToAuxStatus());
                        }
                }
                mpStreamAbstractionAAMP->ResetESChangeStatus();
                mpStreamAbstractionAAMP->Start();
                if (!mbUsingExternalPlayer)
                {
                        if (mbPlayEnabled)
                                mStreamSink->Stream();
                }
        }
 
        if (tuneType == eTUNETYPE_SEEK || tuneType == eTUNETYPE_SEEKTOLIVE || tuneType == eTUNETYPE_SEEKTOEND)
        {
                mSeekOperationInProgress = false;
                // Pipeline is not configured if mbPlayEnabled is false, so not required
                if (mbPlayEnabled && seekWhilePaused == false && pipeline_paused == true)
                {
                        if(!mStreamSink->Pause(true, false))
                        {
                                AAMPLOG_INFO("mStreamSink Pause failed");
                        }
                }
        }
 
#ifdef AAMP_CC_ENABLED
        if(!mIsFakeTune)
        {
                AAMPLOG_INFO("mCCId: %d",mCCId);
                // if mCCId has non zero value means it is same instance and cc release was not calle then dont get id. if zero then call getid.
                if(mCCId == 0 )
                {
                        mCCId = AampCCManager::GetInstance()->GetId();
                }
                //restore CC if it was enabled for previous content.
                if(mIsInbandCC)
                        AampCCManager::GetInstance()->RestoreCC();
        }
#endif
 
        if (tuneType == eTUNETYPE_SEEK || tuneType == eTUNETYPE_SEEKTOLIVE || tuneType == eTUNETYPE_SEEKTOEND)
        {
                if (HasSidecarData())
                { // has sidecar data
                        if (mpStreamAbstractionAAMP)
                                mpStreamAbstractionAAMP->ResumeSubtitleAfterSeek(subtitles_muted, mData);
                }
 
                if ((mpStreamAbstractionAAMP) && (!mTextStyle.empty()))
                {
                        // Restore the subtitle text style after a seek.
                        (void)mpStreamAbstractionAAMP->SetTextStyle(mTextStyle);
                }
        }
 
        if (newTune && !mIsFakeTune)
        {
                PrivAAMPState state;
                GetState(state);
                if((state != eSTATE_ERROR) && ((mMediaFormat != eMEDIAFORMAT_OTA) || (mMediaFormat != eMEDIAFORMAT_RMF)))
                {
                        /*For OTA/RMF this event will be generated from StreamAbstractionAAMP_OTA*/
                        SetState(eSTATE_PREPARED);
                        SendMediaMetadataEvent();
                }
        }
}
 
/**
 * @brief Reload TSB for same URL .
 */
void PrivateInstanceAAMP::ReloadTSB()
{
        TuneType tuneType =  eTUNETYPE_SEEK;
 
        mEventManager->SetPlayerState(eSTATE_IDLE);
        mManifestUrl = mTsbSessionRequestUrl + "&reloadTSB=true";
        // To post player configurations to fog on 1st time tune
        long configPassCode = -1;
        if(mTSBEnabled && ISCONFIGSET_PRIV(eAAMPConfig_EnableAampConfigToFog))
        {
                configPassCode = LoadFogConfig();
        }
        if(configPassCode == 200 || configPassCode == 204 || configPassCode == 206)
        {
                mMediaFormat = GetMediaFormatType(mManifestUrl.c_str());
                ResumeDownloads();
 
                mIsFirstRequestToFOG = (mTSBEnabled == true);
 
                {
                        AAMPLOG_WARN("Reloading TSB, URL: %s", mManifestUrl.c_str());
                }
        }
}
 
/**
 * @brief Tune API
 */
void PrivateInstanceAAMP::Tune(const char *mainManifestUrl, bool autoPlay, const char *contentType, bool bFirstAttempt, bool bFinalAttempt,const char *pTraceID,bool audioDecoderStreamSync)
{
        int iCacheMaxSize = 0;
        int maxDrmSession = 1;
        double tmpVar=0;
        int intTmpVar=0;
        
        TuneType tuneType =  eTUNETYPE_NEW_NORMAL;
        const char *remapUrl = mConfig->GetChannelOverride(mainManifestUrl);
        if (remapUrl )
        {
                const char *remapLicenseUrl = NULL;
                mainManifestUrl = remapUrl;
                remapLicenseUrl = mConfig->GetChannelLicenseOverride(mainManifestUrl);
                if (remapLicenseUrl )
                {
                        AAMPLOG_INFO("Channel License Url Override: [%s]", remapLicenseUrl);
                        SETCONFIGVALUE_PRIV(AAMP_TUNE_SETTING,eAAMPConfig_LicenseServerUrl,std::string(remapLicenseUrl));
                }
        }
        mEventManager->SetPlayerState(eSTATE_IDLE);
        mConfig->CustomSearch(mainManifestUrl,mPlayerId,mAppName);
 
        mConfig->logging.setLogLevel(eLOGLEVEL_INFO);
        gpGlobalConfig->logging.setLogLevel(eLOGLEVEL_INFO);
 
        GETCONFIGVALUE_PRIV(eAAMPConfig_PlaybackOffset,seek_pos_seconds);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredAudioRendition,preferredRenditionString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredAudioCodec,preferredCodecString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredAudioLanguage,preferredLanguagesString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredAudioLabel,preferredLabelsString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredAudioType,preferredTypeString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredTextRendition,preferredTextRenditionString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredTextLanguage,preferredTextLanguagesString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredTextLabel,preferredTextLabelString);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredTextType,preferredTextTypeString);
        UpdatePreferredAudioList();
        GETCONFIGVALUE_PRIV(eAAMPConfig_DRMDecryptThreshold,mDrmDecryptFailCount);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreCachePlaylistTime,mPreCacheDnldTimeWindow);
        GETCONFIGVALUE_PRIV(eAAMPConfig_HarvestCountLimit,mHarvestCountLimit);
        GETCONFIGVALUE_PRIV(eAAMPConfig_HarvestConfig,mHarvestConfig);
        GETCONFIGVALUE_PRIV(eAAMPConfig_AuthToken,mSessionToken);
        GETCONFIGVALUE_PRIV(eAAMPConfig_SubTitleLanguage,mSubLanguage);
        GETCONFIGVALUE_PRIV(eAAMPConfig_TLSVersion,mSupportedTLSVersion);
        mAsyncTuneEnabled = ISCONFIGSET_PRIV(eAAMPConfig_AsyncTune);
        GETCONFIGVALUE_PRIV(eAAMPConfig_LivePauseBehavior,intTmpVar);
        mPausedBehavior = (PausedBehavior)intTmpVar;
        GETCONFIGVALUE_PRIV(eAAMPConfig_NetworkTimeout,tmpVar);
        mNetworkTimeoutMs = (long)CONVERT_SEC_TO_MS(tmpVar);
        GETCONFIGVALUE_PRIV(eAAMPConfig_ManifestTimeout,tmpVar);
        mManifestTimeoutMs = (long)CONVERT_SEC_TO_MS(tmpVar);
        GETCONFIGVALUE_PRIV(eAAMPConfig_PlaylistTimeout,tmpVar);
        mPlaylistTimeoutMs = (long)CONVERT_SEC_TO_MS(tmpVar);
        if(mPlaylistTimeoutMs <= 0) mPlaylistTimeoutMs = mManifestTimeoutMs;
        mLogTimetoTopProfile = true;
        // Reset mProgramDateTime to 0 , to avoid spill over to next tune if same session is 
        // reused 
        mProgramDateTime = 0;
        mMPDPeriodsInfo.clear();
        // Reset current audio/text track index
        mCurrentAudioTrackIndex = -1;
        mCurrentTextTrackIndex = -1;
 
        GETCONFIGVALUE_PRIV(eAAMPConfig_SchemeIdUriDaiStream,mSchemeIdUriDai);
 
        // Set the EventManager config
        // TODO When faketune code is added later , push the faketune status here 
        mEventManager->SetAsyncTuneState(mAsyncTuneEnabled);
        mIsFakeTune = strcasestr(mainManifestUrl, "fakeTune=true");
        if(mIsFakeTune)
        {
                mConfig->logging.setLogLevel(eLOGLEVEL_FATAL);
                gpGlobalConfig->logging.setLogLevel(eLOGLEVEL_FATAL);
        }
        mEventManager->SetFakeTuneFlag(mIsFakeTune);
 
        mTSBEnabled = strcasestr(mainManifestUrl, "tsb?") && ISCONFIGSET_PRIV(eAAMPConfig_Fog);
        SETCONFIGVALUE_PRIV(AAMP_STREAM_SETTING, eAAMPConfig_InterruptHandling, (mTSBEnabled && strcasestr(mainManifestUrl, "networkInterruption=true")));
        if(!ISCONFIGSET_PRIV(eAAMPConfig_UseAbsoluteTimeline) && ISCONFIGSET_PRIV(eAAMPConfig_InterruptHandling))
        {
                AAMPLOG_INFO("Absolute timeline reporting enabled for interrupt enabled TSB stream");
                SETCONFIGVALUE_PRIV(AAMP_TUNE_SETTING, eAAMPConfig_UseAbsoluteTimeline, true);
        }
        if (bFirstAttempt)
        {
                // To post player configurations to fog on 1st time tune
                if(mTSBEnabled && ISCONFIGSET_PRIV(eAAMPConfig_EnableAampConfigToFog))
                {
                        LoadFogConfig();
                }
                else
                {
                        LoadAampAbrConfig();
                }
        }
        //temporary hack for peacock
        if (STARTS_WITH_IGNORE_CASE(mAppName.c_str(), "peacock"))
        {
                if(NULL == mAampCacheHandler)
                {
                        mAampCacheHandler = new AampCacheHandler(mConfig->GetLoggerInstance());
                }
#if defined(AAMP_MPD_DRM) || defined(AAMP_HLS_DRM)
                // read the configured max drm session
                GETCONFIGVALUE_PRIV(eAAMPConfig_MaxDASHDRMSessions,maxDrmSession);
                if(NULL == mDRMSessionManager)
                {
                        mDRMSessionManager = new AampDRMSessionManager(mLogObj, maxDrmSession);
                }
#endif
        }
 
        /* Reset counter in new tune */
        mManifestRefreshCount = 0;
        
        // For PreCaching of playlist , no max limit set as size will vary for each playlist length
        GETCONFIGVALUE_PRIV(eAAMPConfig_MaxPlaylistCacheSize,iCacheMaxSize);
        if(iCacheMaxSize != MAX_PLAYLIST_CACHE_SIZE)
        {
                getAampCacheHandler()->SetMaxPlaylistCacheSize(iCacheMaxSize*1024); // convert KB inputs to bytes
        }
        else if(mPreCacheDnldTimeWindow > 0)
        {
                // if precaching enabled, then set cache to infinite
                // support download of all the playlist files
                getAampCacheHandler()->SetMaxPlaylistCacheSize(PLAYLIST_CACHE_SIZE_UNLIMITED);
        }
 
        // Set max no of init fragment to be maintained in cache table, ByDefault 5.
        GETCONFIGVALUE_PRIV(eAAMPConfig_MaxInitFragCachePerTrack,iCacheMaxSize);
        if(iCacheMaxSize != MAX_INIT_FRAGMENT_CACHE_PER_TRACK)
        {
                getAampCacheHandler()->SetMaxInitFragCacheSize(iCacheMaxSize);
        }
 
        mAudioDecoderStreamSync = audioDecoderStreamSync;
 
 
        mMediaFormat = GetMediaFormatType(mainManifestUrl);
 
        mbUsingExternalPlayer = (mMediaFormat == eMEDIAFORMAT_OTA) || (mMediaFormat== eMEDIAFORMAT_HDMI) || (mMediaFormat==eMEDIAFORMAT_COMPOSITE) || \
                (mMediaFormat == eMEDIAFORMAT_RMF);
 
        if (NULL == mStreamSink)
        {
                mStreamSink = new AAMPGstPlayer(mLogObj, this);
        }
        /* Initialize gstreamer plugins with correct priority to co-exist with webkit plugins.
         * Initial priority of aamp plugins is PRIMARY which is less than webkit plugins.
         * if aamp->Tune is called, aamp plugins should be used, so set priority to a greater value
         * than that of that of webkit plugins*/
        static bool gstPluginsInitialized = false;
        if ((!gstPluginsInitialized) && (!mbUsingExternalPlayer))
        {
                gstPluginsInitialized = true;
                AAMPGstPlayer::InitializeAAMPGstreamerPlugins(mLogObj);
        }
 
        mbPlayEnabled = autoPlay;
        mPlayerPreBuffered = !autoPlay ;
        
        ResumeDownloads();
 
        if (!autoPlay)
        {
                pipeline_paused = true;
                AAMPLOG_WARN("AutoPlay disabled; Just caching the stream now.");
        }
 
        mIsDefaultOffset = (AAMP_DEFAULT_PLAYBACK_OFFSET == seek_pos_seconds);
        if (mIsDefaultOffset)
        {
                // eTUNETYPE_NEW_NORMAL
                // default behaviour is play live streams from 'live' point and VOD streams from the start
                seek_pos_seconds = 0;
        }
        else if (-1 == seek_pos_seconds)
        {
                // eTUNETYPE_NEW_NORMAL
                // behaviour is play live streams from 'live' point and VOD streams skip to the end (this will
                // be corrected later for vod)
                seek_pos_seconds = 0;
        }
        else
        {
                AAMPLOG_WARN("PrivateInstanceAAMP: seek position already set, so eTUNETYPE_NEW_SEEK");
                tuneType = eTUNETYPE_NEW_SEEK;
        }
 
        AAMPLOG_INFO("Paused behavior : %d", mPausedBehavior);
 
        for(int i = 0; i < eCURLINSTANCE_MAX; i++)
        {
                //cookieHeaders[i].clear();
                httpRespHeaders[i].type = eHTTPHEADERTYPE_UNKNOWN;
                httpRespHeaders[i].data.clear();
        }
 
        //Add Custom Header via config
        {
                std::string customLicenseHeaderStr;
                GETCONFIGVALUE_PRIV(eAAMPConfig_CustomHeaderLicense,customLicenseHeaderStr);
                if(!customLicenseHeaderStr.empty())
                {
                        if (ISCONFIGSET_PRIV(eAAMPConfig_CurlLicenseLogging))
                        {
                                AAMPLOG_WARN("CustomHeader :%s",customLicenseHeaderStr.c_str());
                        }
                        char* token = NULL;
                        char* tokenHeader = NULL;
                        char* str = (char*) customLicenseHeaderStr.c_str();
 
                        while ((token = strtok_r(str, ";", &str)))
                        {
                                int headerTokenIndex = 0;
                                std::string headerName;
                                std::vector<std::string> headerValue;
    
                                while ((tokenHeader = strtok_r(token, ":", &token)))
                                {
                                        if(headerTokenIndex == 0)
                                                headerName = tokenHeader;
                                        else if(headerTokenIndex == 1)
                                                headerValue.push_back(std::string(tokenHeader));
                                        else
                                                break;
 
                                        headerTokenIndex++;
                                }
                                if(!headerName.empty() && !headerValue.empty())
                                {
                                        AddCustomHTTPHeader(headerName, headerValue, true);
                                }
                        }
                }
        }
        /** Least priority operator setting will override the value only if it is not set from dev config **/ 
        SETCONFIGVALUE_PRIV(AAMP_TUNE_SETTING,eAAMPConfig_WideVineKIDWorkaround,IsWideVineKIDWorkaround(mainManifestUrl));
        mIsWVKIDWorkaround = ISCONFIGSET_PRIV(eAAMPConfig_WideVineKIDWorkaround);
        if (mIsWVKIDWorkaround)
        {
                /** Set prefered DRM as Widevine with highest configuration **/
                AAMPLOG_INFO("WideVine KeyID workaround present: Setting preferred DRM as Widevine");
                SETCONFIGVALUE_PRIV(AAMP_TUNE_SETTING,eAAMPConfig_PreferredDRM,(int)eDRM_WideVine);
        }
 
        std::tie(mManifestUrl, mDrmInitData) = ExtractDrmInitData(mainManifestUrl);
        
        mIsVSS = (strstr(mainManifestUrl, VSS_MARKER) || strstr(mainManifestUrl, VSS_MARKER_FOG));
        mTuneCompleted  =       false;
        mPersistedProfileIndex  =       -1;
        mServiceZone.clear(); //clear the value if present
        mIsIframeTrackPresent = false;
        mIsTrackIdMismatch = false;
        mCurrentAudioTrackId = -1;
        mCurrentVideoTrackId = -1;
        mCurrentDrm = nullptr;
 
        // DELIA-47965: Calling SetContentType without checking contentType != NULL, so that
        // mContentType will be reset to ContentType_UNKNOWN at the start of tune by default
        SetContentType(contentType);
        if (ContentType_CDVR == mContentType)
        {
                mIscDVR = true;
        }
 
        SetLowLatencyServiceConfigured(false);
 
        UpdateLiveOffset();
#ifdef AAMP_CC_ENABLED
        if (eMEDIAFORMAT_OTA == mMediaFormat)
        {
                if (ISCONFIGSET_PRIV(eAAMPConfig_NativeCCRendering))
                {
                        AampCCManager::GetInstance()->SetParentalControlStatus(false);
                }
        }
#endif
        
        if(bFirstAttempt)
        {
                mTuneAttempts = 1;      //Only the first attempt is xreInitiated.
                mPlayerLoadTime = NOW_STEADY_TS_MS;
                mLogTune = true;
                mFirstProgress = true;
        }
        else
        {
                mTuneAttempts++;
        }
        profiler.TuneBegin();
        ResetBufUnderFlowStatus();
 
        if( !remapUrl )
        {
                std::string mapMPDStr, mapM3U8Str;
                GETCONFIGVALUE_PRIV(eAAMPConfig_MapMPD,mapMPDStr);
                GETCONFIGVALUE_PRIV(eAAMPConfig_MapM3U8,mapM3U8Str);
                if (!mapMPDStr.empty() && mMediaFormat == eMEDIAFORMAT_HLS && (mContentType != ContentType_EAS)) //Don't map, if it is dash and dont map if it is EAS
                {
                        std::string hostName = aamp_getHostFromURL(mManifestUrl);
                        if((hostName.find(mapMPDStr) != std::string::npos) || (mTSBEnabled && mManifestUrl.find(mapMPDStr) != std::string::npos))
                        {
                                replace(mManifestUrl, ".m3u8", ".mpd");
                                mMediaFormat = eMEDIAFORMAT_DASH;
                        }
                }
                else if (!mapM3U8Str.empty() && mMediaFormat == eMEDIAFORMAT_DASH)
                {
                        std::string hostName = aamp_getHostFromURL(mManifestUrl);
                        if((hostName.find(mapM3U8Str) != std::string::npos) || (mTSBEnabled && mManifestUrl.find(mapM3U8Str) != std::string::npos))
                        {
                                replace(mManifestUrl, ".mpd" , ".m3u8");
                                mMediaFormat = eMEDIAFORMAT_HLS;
                        }
                }
                //DELIA-47890 Fog can be disable by  having option fog=0 option in aamp.cfg,based on  that gpGlobalConfig->noFog is updated
                //Removed variable gpGlobalConfig->fogSupportsDash as it has similar usage
                if(!ISCONFIGSET_PRIV(eAAMPConfig_Fog))
                {
                        DeFog(mManifestUrl);
                }
 
                if (ISCONFIGSET_PRIV(eAAMPConfig_ForceEC3))
                {
                        replace(mManifestUrl,".m3u8", "-eac3.m3u8");
                }
                if (ISCONFIGSET_PRIV(eAAMPConfig_DisableEC3))
                {
                        replace(mManifestUrl, "-eac3.m3u8", ".m3u8");
                }
 
                if(ISCONFIGSET_PRIV(eAAMPConfig_ForceHttp))
                {
                        replace(mManifestUrl, "https://", "http://");
                        if(mTSBEnabled)
                        {
                                ForceHttpCoversionforFog(mManifestUrl,"https","http");
                        }
                }
 
                if (mManifestUrl.find("mpd")!= std::string::npos) // new - limit this option to linear content as part of DELIA-23975
                {
                        replace(mManifestUrl, "-eac3.mpd", ".mpd");
                } // mpd
        } // !remap_url
 
        mIsFirstRequestToFOG = (mTSBEnabled == true);
 
        {
                char tuneStrPrefix[64];
                mTsbSessionRequestUrl.clear();
                memset(tuneStrPrefix, '\0', sizeof(tuneStrPrefix));
                if (!mAppName.empty())
                {
                        snprintf(tuneStrPrefix, sizeof(tuneStrPrefix), "%s PLAYER[%d] APP: %s",(mbPlayEnabled?STRFGPLAYER:STRBGPLAYER), mPlayerId, mAppName.c_str());
                }
                else
                {
                        snprintf(tuneStrPrefix, sizeof(tuneStrPrefix), "%s PLAYER[%d]", (mbPlayEnabled?STRFGPLAYER:STRBGPLAYER), mPlayerId);
                }
 
                if(mManifestUrl.length() < MAX_URL_LOG_SIZE)
                {
                        AAMPLOG_WARN("%s aamp_tune: attempt: %d format: %s URL: %s", tuneStrPrefix, mTuneAttempts, mMediaFormatName[mMediaFormat], mManifestUrl.c_str());
                }
                else
                {
                        AAMPLOG_WARN("%s aamp_tune: attempt: %d format: %s URL: (BIG)", tuneStrPrefix, mTuneAttempts, mMediaFormatName[mMediaFormat]);
                        AAMPLOG_INFO("URL: %s", mManifestUrl.c_str());
                }
                if(IsTSBSupported())
                {
                        mTsbSessionRequestUrl = mManifestUrl;
                }
        }
 
        // this function uses mIsVSS and mTSBEnabled, hence it should be called after these variables are updated.
        ExtractServiceZone(mManifestUrl);
        SetTunedManifestUrl(mTSBEnabled);
 
        if(bFirstAttempt)
        { // TODO: make mFirstTuneFormat of type MediaFormat
                mfirstTuneFmt = (int)mMediaFormat;
        }
        mCdaiObject = NULL;
        AcquireStreamLock();
        TuneHelper(tuneType);
 
        //Apply the cached video mute call as it got invoked when stream lock was not available
        if(mApplyCachedVideoMute)
        {
                mApplyCachedVideoMute = false;
                AAMPLOG_INFO("Cached videoMute is being executed, mute value: %d", video_muted);
                if (mpStreamAbstractionAAMP)
                {
                        //There two fns are being called in PlayerInstanceAAMP::SetVideoMute
                        SetVideoMute(video_muted);
                        SetCCStatus(video_muted ? false : !subtitles_muted);
                }
        }
        ReleaseStreamLock();
 
        // To check and apply stored video rectangle properties
        if (mApplyVideoRect)
        {
                if ((mMediaFormat == eMEDIAFORMAT_OTA) || (mMediaFormat == eMEDIAFORMAT_HDMI) || (mMediaFormat == eMEDIAFORMAT_COMPOSITE) || \
                        (mMediaFormat == eMEDIAFORMAT_RMF))
                {
                        mpStreamAbstractionAAMP->SetVideoRectangle(mVideoRect.horizontalPos, mVideoRect.verticalPos, mVideoRect.width, mVideoRect.height);
                }
                else
                {
                        mStreamSink->SetVideoRectangle(mVideoRect.horizontalPos, mVideoRect.verticalPos, mVideoRect.width, mVideoRect.height);
                }
                AAMPLOG_INFO("Update SetVideoRectangle x:%d y:%d w:%d h:%d", mVideoRect.horizontalPos, mVideoRect.verticalPos, mVideoRect.width, mVideoRect.height);
                mApplyVideoRect = false;
        }
        // do not change location of this set, it should be done after sending perviouse VideoEnd data which
        // is done in TuneHelper->SendVideoEndEvent function.
        if(pTraceID)
        {
                this->mTraceUUID = pTraceID;
                AAMPLOG_WARN("CMCD Session Id:%s", this->mTraceUUID.c_str());
        }
        else
        {
                this->mTraceUUID = "unknown";
        }
        //generate uuid/session id for applications which do not send id along with tune.
        if(ISCONFIGSET_PRIV(eAAMPConfig_EnableCMCD) && pTraceID == NULL)
        {
                uuid_t uuid;
                uuid_generate(uuid);
                char sid[MAX_SESSION_ID_LENGTH];
                uuid_unparse(uuid, sid);
                for (char *ptr = sid; *ptr; ++ptr) {
                        *ptr = tolower(*ptr);
                }
                this->mTraceUUID = sid;
                AAMPLOG_WARN("CMCD Session Id generated:%s", this->mTraceUUID.c_str());
        }
}
 
/**
 *  @brief Get Language preference from aamp.cfg.
 */
LangCodePreference PrivateInstanceAAMP::GetLangCodePreference()
{
        int langCodePreference;
        GETCONFIGVALUE_PRIV(eAAMPConfig_LanguageCodePreference,langCodePreference);
        return (LangCodePreference)langCodePreference;
}
 
/**
 *  @brief Get Mediaformat types by parsing the url
 */
MediaFormat PrivateInstanceAAMP::GetMediaFormatType(const char *url)
{
        MediaFormat rc = eMEDIAFORMAT_UNKNOWN;
        std::string urlStr(url); // for convenience, convert to std::string
 
#ifdef TRUST_LOCATOR_EXTENSION_IF_PRESENT // disable to exersize alternate path
        if( urlStr.rfind("hdmiin:",0)==0 )
        {
                rc = eMEDIAFORMAT_HDMI;
        }
        else if( urlStr.rfind("cvbsin:",0)==0 )
        {
                rc = eMEDIAFORMAT_COMPOSITE;
        }
        else if((urlStr.rfind("live:",0)==0) || (urlStr.rfind("tune:",0)==0)  || (urlStr.rfind("mr:",0)==0)) 
        {
                rc = eMEDIAFORMAT_OTA;
        }
        else if(urlStr.rfind("ocap:",0)==0)
        {
                rc = eMEDIAFORMAT_RMF;
        }       
        else if(urlStr.rfind("http://127.0.0.1", 0) == 0) // starts with localhost
        { // where local host is used; inspect further to determine if this locator involves FOG
 
                size_t fogUrlStart = urlStr.find("recordedUrl=", 16); // search forward, skipping 16-char http://127.0.0.1
 
                if(fogUrlStart != std::string::npos)
                { // definitely FOG - extension is inside recordedUrl URI parameter
 
                        size_t fogUrlEnd = urlStr.find("&", fogUrlStart); // end of recordedUrl
 
                        if(fogUrlEnd != std::string::npos)
                        {
                                if(urlStr.rfind("m3u8", fogUrlEnd) != std::string::npos)
                                {
                                        rc = eMEDIAFORMAT_HLS;
                                }
                                else if(urlStr.rfind("mpd", fogUrlEnd)!=std::string::npos)
                                {
                                        rc = eMEDIAFORMAT_DASH;
                                }
 
                                // should never get here with UNKNOWN format, but if we do, just fall through to normal locator scanning
                        }
                }
        }
        
        if(rc == eMEDIAFORMAT_UNKNOWN)
        { // do 'normal' (non-FOG) locator parsing
 
                size_t extensionEnd = urlStr.find("?"); // delimited for URI parameters, or end-of-string
                std::size_t extensionStart = urlStr.rfind(".", extensionEnd); // scan backwards to find final "."
                int extensionLength;
 
                if(extensionStart != std::string::npos)
                { // found an extension
                        if(extensionEnd == std::string::npos)
                        {
                                extensionEnd = urlStr.length();
                        }
 
                        extensionStart++; // skip past the "." - no reason to re-compare it
 
                        extensionLength = (int)(extensionEnd - extensionStart); // bytes between "." and end of query delimiter/end of string
 
                        if(extensionLength == 4 && urlStr.compare(extensionStart, extensionLength, "m3u8") == 0)
                        {
                                rc = eMEDIAFORMAT_HLS;
                        }
                        else if(extensionLength == 3)
                        {
                                if(urlStr.compare(extensionStart,extensionLength,"mpd") == 0)
                                {
                                        rc = eMEDIAFORMAT_DASH;
                                }
                                else if(urlStr.compare(extensionStart,extensionLength,"mp3") == 0 || urlStr.compare(extensionStart,extensionLength,"mp4") == 0 ||
                                        urlStr.compare(extensionStart,extensionLength,"mkv") == 0)
                                {
                                        rc = eMEDIAFORMAT_PROGRESSIVE;
                                }
                        }
                        else if((extensionLength == 2) || (urlStr.rfind("srt:",0)==0)) 
                        {
                                if((urlStr.compare(extensionStart,extensionLength,"ts") == 0) || (urlStr.rfind("srt:",0)==0))
                                {
                                        rc = eMEDIAFORMAT_PROGRESSIVE;
                                }
                        }
                }
        }
#endif // TRUST_LOCATOR_EXTENSION_IF_PRESENT
 
        if(rc == eMEDIAFORMAT_UNKNOWN)
        {
                // no extension - sniff first few bytes of file to disambiguate
                struct GrowableBuffer sniffedBytes = {0, 0, 0};
                std::string effectiveUrl;
                long http_error;
                double downloadTime;
                long bitrate;
                int fogError;
 
                mOrigManifestUrl.hostname=aamp_getHostFromURL(url);
                mOrigManifestUrl.isRemotehost = !(aamp_IsLocalHost(mOrigManifestUrl.hostname));
                CurlInit(eCURLINSTANCE_MANIFEST_PLAYLIST, 1, GetNetworkProxy());
 
                bool gotManifest = GetFile(url,
                                                        &sniffedBytes,
                                                        effectiveUrl,
                                                        &http_error,
                                                        &downloadTime,
                                                        "0-150", // download first few bytes only
                                                        // TODO: ideally could use "0-6" for range but write_callback sometimes not called before curl returns http 206
                                                        eCURLINSTANCE_MANIFEST_PLAYLIST,
                                                        false,
                                                        eMEDIATYPE_MANIFEST,
                                                        &bitrate,
                                                        &fogError,
                                                        0.0);
 
                if(gotManifest)
                {
                        if(sniffedBytes.len >= 7 && memcmp(sniffedBytes.ptr, "#EXTM3U8", 7) == 0)
                        {
                                rc = eMEDIAFORMAT_HLS;
                        }
                        else if((sniffedBytes.len >= 6 && memcmp(sniffedBytes.ptr, "<?xml ", 6) == 0) || // can start with xml
                                         (sniffedBytes.len >= 5 && memcmp(sniffedBytes.ptr, "<MPD ", 5) == 0)) // or directly with mpd
                        { // note: legal to have whitespace before leading tag
                                aamp_AppendNulTerminator(&sniffedBytes);
                                if (strstr(sniffedBytes.ptr, "SmoothStreamingMedia"))
                                {
                                        rc = eMEDIAFORMAT_SMOOTHSTREAMINGMEDIA;
                                }
                                else
                                {
                                        rc = eMEDIAFORMAT_DASH;
                                }
                        }
                        else
                        {
                                rc = eMEDIAFORMAT_PROGRESSIVE;
                        }
                }
                aamp_Free(&sniffedBytes);
                CurlTerm(eCURLINSTANCE_MANIFEST_PLAYLIST);
        }
        return rc;
}
 
/**
 *   @brief Check if AAMP is in stalled state after it pushed EOS to
 *   notify discontinuity
 */
void PrivateInstanceAAMP::CheckForDiscontinuityStall(MediaType mediaType)
{
        AAMPLOG_TRACE("Enter mediaType %d", mediaType);
        long discontinuityTimeoutValue;
        GETCONFIGVALUE_PRIV(eAAMPConfig_DiscontinuityTimeout,discontinuityTimeoutValue);
        if(!(mStreamSink->CheckForPTSChangeWithTimeout(discontinuityTimeoutValue)))
        {
                pthread_mutex_lock(&mLock);
 
                if (mDiscontinuityTuneOperationId != 0 || mDiscontinuityTuneOperationInProgress)
                {
                        AAMPLOG_WARN("PrivateInstanceAAMP: Ignored retune!! Discontinuity handler already spawned(%d) or inprogress(%d)",
                                                        mDiscontinuityTuneOperationId, mDiscontinuityTuneOperationInProgress);
                        pthread_mutex_unlock(&mLock);
                        return;
                }
 
                pthread_mutex_unlock(&mLock);
 
                AAMPLOG_INFO("No change in PTS for more than %ld ms, schedule retune!", discontinuityTimeoutValue);
                ResetDiscontinuityInTracks();
 
                ResetTrackDiscontinuityIgnoredStatus();
                ScheduleRetune(eSTALL_AFTER_DISCONTINUITY, mediaType);
        }
        AAMPLOG_TRACE("Exit mediaType %d", mediaType);
}
 
/**
 * @brief updates mServiceZone (service zone) member with string extracted from locator &sz URI parameter
 */
void PrivateInstanceAAMP::ExtractServiceZone(std::string url)
{
        if(mIsVSS && !url.empty())
        {
                if(mTSBEnabled)
                { // extract original locator from FOG recordedUrl URI parameter
                        DeFog(url);
                }
                size_t vssStart = url.find(VSS_MARKER);
                if( vssStart != std::string::npos )
                {
                        vssStart += VSS_MARKER_LEN; // skip "?sz="
                        size_t vssLen = url.find('&',vssStart);
                        if( vssLen != std::string::npos )
                        {
                                vssLen -= vssStart;
                        }
                        mServiceZone = url.substr(vssStart, vssLen );
                        aamp_DecodeUrlParameter(mServiceZone); // DELIA-44703
                }
                else
                {
                        AAMPLOG_ERR("PrivateInstanceAAMP: ERROR: url does not have vss marker :%s ",url.c_str());
                }
        }
}
 
/**
 *  @brief Set Content Type
 */
std::string PrivateInstanceAAMP::GetContentTypString()
{
    std::string strRet;
    switch(mContentType)
    {
        case ContentType_CDVR :
        {
            strRet = "CDVR"; //cdvr
            break;
        }
        case ContentType_VOD :
        {
            strRet = "VOD"; //vod
            break;
        }    
        case ContentType_LINEAR :
        {
            strRet = "LINEAR"; //linear
            break;
        }    
        case ContentType_IVOD :
        {
            strRet = "IVOD"; //ivod
            break;
        }    
        case ContentType_EAS :
        {
            strRet ="EAS"; //eas
            break;
        }    
        case ContentType_CAMERA :
        {
            strRet = "XfinityHome"; //camera
            break;
        }    
        case ContentType_DVR :
        {
            strRet = "DVR"; //dvr
            break;
        }    
        case ContentType_MDVR :
        {
            strRet =  "MDVR" ; //mdvr
            break;
        }    
        case ContentType_IPDVR :
        {
            strRet ="IPDVR" ; //ipdvr
            break;
        }    
        case ContentType_PPV :
        {
            strRet =  "PPV"; //ppv
            break;
        }
        case ContentType_OTT :
        {
            strRet =  "OTT"; //ott
            break;
        }
        case ContentType_OTA :
        {
            strRet =  "OTA"; //ota
            break;
        }
        case ContentType_SLE :
        {
            strRet = "SLE"; // single live event
            break;
        }
        default:
        {
            strRet =  "Unknown";
            break;
        }
     }
 
    return strRet;
}
 
/**
 * @brief Notify about sink buffer full
 */
void PrivateInstanceAAMP::NotifySinkBufferFull(MediaType type)
{
        if(type != eMEDIATYPE_VIDEO)
                return;
 
        if(mpStreamAbstractionAAMP)
        {
                MediaTrack* video = mpStreamAbstractionAAMP->GetMediaTrack(eTRACK_VIDEO);
                if(video && video->enabled)
                        video->OnSinkBufferFull();
        }
}
 
/**
 * @brief Set Content Type
 */
void PrivateInstanceAAMP::SetContentType(const char *cType)
{
        mContentType = ContentType_UNKNOWN; //default unknown
        if(NULL != cType)
        {
                mPlaybackMode = std::string(cType);
                if(mPlaybackMode == "CDVR")
                {
                        mContentType = ContentType_CDVR; //cdvr
                }
                else if(mPlaybackMode == "VOD")
                {
                        mContentType = ContentType_VOD; //vod
                }
                else if(mPlaybackMode == "LINEAR_TV")
                {
                        mContentType = ContentType_LINEAR; //linear
                }
                else if(mPlaybackMode == "IVOD")
                {
                        mContentType = ContentType_IVOD; //ivod
                }
                else if(mPlaybackMode == "EAS")
                {
                        mContentType = ContentType_EAS; //eas
                }
                else if(mPlaybackMode == "xfinityhome")
                {
                        mContentType = ContentType_CAMERA; //camera
                }
                else if(mPlaybackMode == "DVR")
                {
                        mContentType = ContentType_DVR; //dvr
                }
                else if(mPlaybackMode == "MDVR")
                {
                        mContentType = ContentType_MDVR; //mdvr
                }
                else if(mPlaybackMode == "IPDVR")
                {
                        mContentType = ContentType_IPDVR; //ipdvr
                }
                else if(mPlaybackMode == "PPV")
                {
                        mContentType = ContentType_PPV; //ppv
                }
                else if(mPlaybackMode == "OTT")
                {
                        mContentType = ContentType_OTT; //ott
                }
                else if(mPlaybackMode == "OTA")
                {
                        mContentType = ContentType_OTA; //ota
                }
                else if(mPlaybackMode == "HDMI_IN")
                {
                        mContentType = ContentType_HDMIIN; //ota
                }
                else if(mPlaybackMode == "COMPOSITE_IN")
                {
                        mContentType = ContentType_COMPOSITEIN; //ota
                }
                else if(mPlaybackMode == "SLE")
                {
                        mContentType = ContentType_SLE; //single live event
                }
        }
}
 
/**
 * @brief Get Content Type
 */
ContentType PrivateInstanceAAMP::GetContentType() const
{
        return mContentType;
}
 
/**
 *   @brief Extract DRM init data from the provided URL
 *          If present, the init data will be removed from the returned URL
 *          and provided as a separate string
 *   @return tuple containing the modified URL and DRM init data
 */
const std::tuple<std::string, std::string> PrivateInstanceAAMP::ExtractDrmInitData(const char *url)
{
        std::string urlStr(url);
        std::string drmInitDataStr;
 
        const size_t queryPos = urlStr.find("?");
        std::string modUrl;
        if (queryPos != std::string::npos)
        {
                // URL contains a query string. Strip off & decode the drmInitData (if present)
                modUrl = urlStr.substr(0, queryPos);
                const std::string parameterDefinition("drmInitData=");
                std::string parameter;
                std::stringstream querySs(urlStr.substr(queryPos + 1, std::string::npos));
                while (std::getline(querySs, parameter, '&'))
                { // with each URI parameter
                        if (parameter.rfind(parameterDefinition, 0) == 0)
                        { // found drmInitData URI parameter
                                drmInitDataStr = parameter.substr(parameterDefinition.length());
                                aamp_DecodeUrlParameter( drmInitDataStr );
                        }
                        else
                        { // filter out drmInitData; reintroduce all other URI parameters
                                modUrl.append((queryPos == modUrl.length()) ? "?" : "&");
                                modUrl.append(parameter);
                        }
                }
                urlStr = modUrl;
        }
        return std::tuple<std::string, std::string>(urlStr, drmInitDataStr);
}
 
/**
 *   @brief Check if autoplay enabled for current stream
 */
bool PrivateInstanceAAMP::IsPlayEnabled()
{
        return mbPlayEnabled;
}
 
/**
 * @brief Soft stop the player instance.
 *
 */
void PrivateInstanceAAMP::detach()
{
        if(mpStreamAbstractionAAMP && mbPlayEnabled) //Player is running
        {
                pipeline_paused = true;
                seek_pos_seconds  = GetPositionSeconds();
                AAMPLOG_WARN("Player %s=>%s and soft release.Detach at position %f", STRFGPLAYER, STRBGPLAYER,seek_pos_seconds );
                DisableDownloads(); //disable download
                mpStreamAbstractionAAMP->SeekPosUpdate(seek_pos_seconds );
                mpStreamAbstractionAAMP->StopInjection();
#ifdef AAMP_CC_ENABLED
                // Stop CC when pipeline is stopped
                if (ISCONFIGSET_PRIV(eAAMPConfig_NativeCCRendering))
                {
                        AampCCManager::GetInstance()->Release(mCCId);
                        mCCId = 0;
                }
#endif
                mStreamSink->Stop(true);
                mbPlayEnabled = false;
                mbDetached=true;
                mPlayerPreBuffered  = false;
                //EnableDownloads();// enable downloads
        }
}
 
/**
 * @brief Get AampCacheHandler instance
 */
AampCacheHandler * PrivateInstanceAAMP::getAampCacheHandler()
{
        return mAampCacheHandler;
}
 
/**
 * @brief Get maximum bitrate value.
 */
long PrivateInstanceAAMP::GetMaximumBitrate()
{
        long lMaxBitrate;
        GETCONFIGVALUE_PRIV(eAAMPConfig_MaxBitrate,lMaxBitrate);
        return lMaxBitrate;
}
 
/**
 * @brief Get minimum bitrate value.
 */
long PrivateInstanceAAMP::GetMinimumBitrate()
{
        long lMinBitrate;
        GETCONFIGVALUE_PRIV(eAAMPConfig_MinBitrate,lMinBitrate);
        return lMinBitrate;
}
 
/**
 * @brief Get default bitrate value.
 */
long PrivateInstanceAAMP::GetDefaultBitrate()
{
        long defaultBitRate;
        GETCONFIGVALUE_PRIV(eAAMPConfig_DefaultBitrate,defaultBitRate);
        return defaultBitRate;
}
 
/**
 * @brief Get Default bitrate for 4K
 */
long PrivateInstanceAAMP::GetDefaultBitrate4K()
{
        long defaultBitRate;
        GETCONFIGVALUE_PRIV(eAAMPConfig_DefaultBitrate4K,defaultBitRate);
        return defaultBitRate;
}
 
/**
 * @brief Get Default Iframe bitrate value.
 */
long PrivateInstanceAAMP::GetIframeBitrate()
{
        long defaultIframeBitRate;
        GETCONFIGVALUE_PRIV(eAAMPConfig_IFrameDefaultBitrate,defaultIframeBitRate);
        return defaultIframeBitRate;
}
 
/**
 * @brief Get Default Iframe bitrate 4K value.
 */
long PrivateInstanceAAMP::GetIframeBitrate4K()
{
        long defaultIframeBitRate4K;
        GETCONFIGVALUE_PRIV(eAAMPConfig_IFrameDefaultBitrate4K,defaultIframeBitRate4K);
        return defaultIframeBitRate4K;
}
 
/**
 * @brief Fetch a file from CDN and update profiler
 */
char *PrivateInstanceAAMP::LoadFragment(ProfilerBucketType bucketType, std::string fragmentUrl, std::string& effectiveUrl, size_t *len, unsigned int curlInstance, const char *range, long * http_code, double *downloadTime, MediaType fileType,int * fogError)
{
        profiler.ProfileBegin(bucketType);
        struct GrowableBuffer fragment = { 0, 0, 0 }; // TODO: leaks if thread killed
        if (!GetFile(fragmentUrl, &fragment, effectiveUrl, http_code, downloadTime, range, curlInstance, true, fileType,NULL,fogError))
        {
                profiler.ProfileError(bucketType, *http_code);
                profiler.ProfileEnd(bucketType);
        }
        else
        {
                profiler.ProfileEnd(bucketType);
        }
        *len = fragment.len;
        return fragment.ptr;
}
 
/**
 * @brief Fetch a file from CDN and update profiler
 */
bool PrivateInstanceAAMP::LoadFragment(CMCDHeaders *pCMCDMetrics,ProfilerBucketType bucketType, std::string fragmentUrl,std::string& effectiveUrl, struct GrowableBuffer *fragment, 
                                        unsigned int curlInstance, const char *range, MediaType fileType,long * http_code, double *downloadTime, long *bitrate,int * fogError, double fragmentDurationSeconds)
{
        bool ret = true;
        profiler.ProfileBegin(bucketType);
        if (!GetFile(fragmentUrl, fragment, effectiveUrl, http_code, downloadTime, range, curlInstance, false,fileType, bitrate, NULL, fragmentDurationSeconds,pCMCDMetrics))
        {
                ret = false;
                profiler.ProfileError(bucketType, *http_code);
                profiler.ProfileEnd(bucketType);
        }
        else
        {
                profiler.ProfileEnd(bucketType);
        }
        return ret;
}
 
/**
 * @brief Push fragment to the gstreamer
 */
void PrivateInstanceAAMP::PushFragment(MediaType mediaType, char *ptr, size_t len, double fragmentTime, double fragmentDuration)
{
        BlockUntilGstreamerWantsData(NULL, 0, 0);
        SyncBegin();
        mStreamSink->SendCopy(mediaType, ptr, len, fragmentTime, fragmentTime, fragmentDuration);
        SyncEnd();
}
 
/**
 * @brief Push fragment to the gstreamer
 */
void PrivateInstanceAAMP::PushFragment(MediaType mediaType, GrowableBuffer* buffer, double fragmentTime, double fragmentDuration)
{
        BlockUntilGstreamerWantsData(NULL, 0, 0);
        SyncBegin();
        if( mStreamSink->SendTransfer(mediaType, buffer->ptr, buffer->len, fragmentTime, fragmentTime, fragmentDuration) )
        {
                aamp_TransferMemory(buffer->ptr);
        }
        else
        { // unable to transfer - free up the buffer we were passed.
                aamp_Free(buffer);
        }
        memset(buffer, 0x00, sizeof(GrowableBuffer));
        SyncEnd();
}
 
/**
 * @brief End of stream reached
 */
void PrivateInstanceAAMP::EndOfStreamReached(MediaType mediaType)
{
        if (mediaType != eMEDIATYPE_SUBTITLE)
        {
                SyncBegin();
                mStreamSink->EndOfStreamReached(mediaType);
                SyncEnd();
 
                // If EOS during Buffering, set Playing and let buffer to dry out
                // Sink is already unpaused by EndOfStreamReached()
                pthread_mutex_lock(&mFragmentCachingLock);
                mFragmentCachingRequired = false;
                PrivAAMPState state;
                GetState(state);
                if(state == eSTATE_BUFFERING)
                {
                        if(mpStreamAbstractionAAMP)
                        {
                                mpStreamAbstractionAAMP->NotifyPlaybackPaused(false);
                        }
                        SetState(eSTATE_PLAYING);
                }
                pthread_mutex_unlock(&mFragmentCachingLock);
        }
}
 
/**
 * @brief Get seek base position
 */
double PrivateInstanceAAMP::GetSeekBase(void)
{
        return seek_pos_seconds;
}
 
/**
 * @brief Get current drm
 */
std::shared_ptr<AampDrmHelper> PrivateInstanceAAMP::GetCurrentDRM(void)
{
        return mCurrentDrm;
}
 
/**
 *    @brief Get available thumbnail tracks.
 */
std::string PrivateInstanceAAMP::GetThumbnailTracks()
{
        std::string op;
        AcquireStreamLock();
        if(mpStreamAbstractionAAMP)
        {
                AAMPLOG_TRACE("Entering PrivateInstanceAAMP");
                std::vector<StreamInfo*> data = mpStreamAbstractionAAMP->GetAvailableThumbnailTracks();
                cJSON *root;
                cJSON *item;
                if(!data.empty())
                {
                        root = cJSON_CreateArray();
                        if(root)
                        {
                                for( int i = 0; i < data.size(); i++)
                                {
                                        cJSON_AddItemToArray(root, item = cJSON_CreateObject());
                                        if(data[i]->bandwidthBitsPerSecond >= 0)
                                        {
                                                char buf[32];
                                                snprintf(buf, sizeof(buf), "%dx%d",data[i]->resolution.width,data[i]->resolution.height);
                                                cJSON_AddStringToObject(item,"RESOLUTION",buf);
                                                cJSON_AddNumberToObject(item,"BANDWIDTH",data[i]->bandwidthBitsPerSecond);
                                        }
                                }
                                char *jsonStr = cJSON_Print(root);
                                if (jsonStr)
                                {
                                        op.assign(jsonStr);
                                        free(jsonStr);
                                }
                                cJSON_Delete(root);
                        }
                }
                AAMPLOG_TRACE("In PrivateInstanceAAMP::Json string:%s",op.c_str());
        }
        ReleaseStreamLock();
        return op;
}
 
/**
 *  @brief Get the Thumbnail Tile data.
 */
std::string PrivateInstanceAAMP::GetThumbnails(double tStart, double tEnd)
{
        std::string rc;
        AcquireStreamLock();
        if(mpStreamAbstractionAAMP)
        {
                std::string baseurl;
                int raw_w, raw_h, width, height;
                std::vector<ThumbnailData> datavec = mpStreamAbstractionAAMP->GetThumbnailRangeData(tStart, tEnd, &baseurl, &raw_w, &raw_h, &width, &height);
                if( !datavec.empty() )
                {
                        cJSON *root = cJSON_CreateObject();
                        if(!baseurl.empty())
                        {
                                cJSON_AddStringToObject(root,"baseUrl",baseurl.c_str());
                        }
                        if(raw_w > 0)
                        {
                                cJSON_AddNumberToObject(root,"raw_w",raw_w);
                        }
                        if(raw_h > 0)
                        {
                                cJSON_AddNumberToObject(root,"raw_h",raw_h);
                        }
                        cJSON_AddNumberToObject(root,"width",width);
                        cJSON_AddNumberToObject(root,"height",height);
 
                        cJSON *tile = cJSON_AddArrayToObject(root,"tile");
                        for( const ThumbnailData &iter : datavec )
                        {
                                cJSON *item;
                                cJSON_AddItemToArray(tile, item = cJSON_CreateObject() );
                                if(!iter.url.empty())
                                {
                                        cJSON_AddStringToObject(item,"url",iter.url.c_str());
                                }
                                cJSON_AddNumberToObject(item,"t",iter.t);
                                cJSON_AddNumberToObject(item,"d",iter.d);
                                cJSON_AddNumberToObject(item,"x",iter.x);
                                cJSON_AddNumberToObject(item,"y",iter.y);
                        }
                        char *jsonStr = cJSON_Print(root);
                        if( jsonStr )
                        {
                                rc.assign( jsonStr );
                        }
                        cJSON_Delete(root);
                }
        }
        ReleaseStreamLock();
        return rc;
}
 
 
TunedEventConfig PrivateInstanceAAMP::GetTuneEventConfig(bool isLive)
{
        int tunedEventConfig;
        GETCONFIGVALUE_PRIV(eAAMPConfig_TuneEventConfig,tunedEventConfig);
        return (TunedEventConfig)tunedEventConfig;
}
 
/**
 * @brief to update the preferredaudio codec, rendition and languages  list
 */
void PrivateInstanceAAMP::UpdatePreferredAudioList()
{
        if(!preferredRenditionString.empty())
        {
                preferredRenditionList.clear();
                std::istringstream ss(preferredRenditionString);
                std::string rendition;
                while(std::getline(ss, rendition, ','))
                {
                        preferredRenditionList.push_back(rendition);
                        AAMPLOG_INFO("Parsed preferred rendition: %s",rendition.c_str());
                }
                AAMPLOG_INFO("Number of preferred Renditions: %lu",
                        preferredRenditionList.size());
        }
 
        if(!preferredCodecString.empty())
        {
                preferredCodecList.clear();
                std::istringstream ss(preferredCodecString);
                std::string codec;
                while(std::getline(ss, codec, ','))
                {
                        preferredCodecList.push_back(codec);
                        AAMPLOG_INFO("Parsed preferred codec: %s",codec.c_str());
                }
                AAMPLOG_INFO("Number of preferred codec: %lu",
                        preferredCodecList.size());
        }
 
        if(!preferredLanguagesString.empty())
        {
                preferredLanguagesList.clear();
                std::istringstream ss(preferredLanguagesString);
                std::string lng;
                while(std::getline(ss, lng, ','))
                {
                        preferredLanguagesList.push_back(lng);
                        AAMPLOG_INFO("Parsed preferred lang: %s",lng.c_str());
                }
                AAMPLOG_INFO("Number of preferred languages: %lu",
                        preferredLanguagesList.size());
        }
        if(!preferredLabelsString.empty())
        {
                preferredLabelList.clear();
                std::istringstream ss(preferredLabelsString);
                std::string lng;
                while(std::getline(ss, lng, ','))
                {
                                preferredLabelList.push_back(lng);
                                AAMPLOG_INFO("Parsed preferred Label: %s",lng.c_str());
                }
                AAMPLOG_INFO("Number of preferred Labels: %lu", preferredLabelList.size());
        }
        
 
}
 
/**
 *  @brief Set async tune configuration for EventPriority
 */
void PrivateInstanceAAMP::SetEventPriorityAsyncTune(bool bValue)
{
        if(bValue)
        {
                mEventPriority = AAMP_MAX_EVENT_PRIORITY;
        }
        else
        {
                mEventPriority = G_PRIORITY_DEFAULT_IDLE;
        }       
}
 
/**
 * @brief Get async tune configuration
 */
bool PrivateInstanceAAMP::GetAsyncTuneConfig()
{
        return mAsyncTuneEnabled;
}
 
/**
 * @brief Set video rectangle
 */
void PrivateInstanceAAMP::UpdateVideoRectangle (int x, int y, int w, int h)
{
        mVideoRect.horizontalPos = x;
        mVideoRect.verticalPos   = y;
        mVideoRect.width = w;
        mVideoRect.height = h;
        mApplyVideoRect = true;
        AAMPLOG_INFO("Backup VideoRectangle x:%d y:%d w:%d h:%d", x, y, w, h);
}
 
/**
 * @brief Set video rectangle
 */
void PrivateInstanceAAMP::SetVideoRectangle(int x, int y, int w, int h)
{
        pthread_mutex_lock(&mStreamLock);
        PrivAAMPState state;
        GetState(state);
 
        //Differenciate IP vs non IP playback
        bool isNonIPPlayback = (mMediaFormat == eMEDIAFORMAT_OTA) || (mMediaFormat == eMEDIAFORMAT_HDMI) || (mMediaFormat == eMEDIAFORMAT_COMPOSITE) || (mMediaFormat == eMEDIAFORMAT_RMF);
 
        // for ATSC eSTATE_PREPARED is sent when tune is successful, as Closed caption data wont be available till tune and stream check for CC is done,
        // for IP eSTATE_PREPARED is done after manifest parsing,
        // Incase of ATSC or HDMI SetVideoRectangle should be called after StreamAbstractionAAMP_OTA::Start or StreamAbstractionAAMP_VIDEOIN::StartHelper which is called tune function after
        // mpStreamAbstractionAAMP object is created, hence if mpStreamAbstractionAAMP is NULL then we should not call SetVideoRectangle and defer it, this happes when SetVideoRectangle called after load.
        // for IP SetVideoRectangle should be called after mStreamSink created i.e > eSTATE_PREPARING
        // hence in below "state" condition state check is done only for IP
 
        if (mpStreamAbstractionAAMP && (isNonIPPlayback || state > eSTATE_PREPARING))
        {
                if (isNonIPPlayback)
                {
                        mpStreamAbstractionAAMP->SetVideoRectangle(x, y, w, h);
                }
                else
                {
                        mStreamSink->SetVideoRectangle(x, y, w, h);
                }
        }
        else
        {
                AAMPLOG_INFO("mpStreamAbstractionAAMP is not Ready, Backup video rect values, current player state: %d", state);
                UpdateVideoRectangle (x, y, w, h);
        }
        pthread_mutex_unlock(&mStreamLock);
}
/**
 *   @brief Set video zoom.
 */
void PrivateInstanceAAMP::SetVideoZoom(VideoZoomMode zoom)
{
        mStreamSink->SetVideoZoom(zoom);
}
 
/**
 *   @brief Enable/ Disable Video.
 */
void PrivateInstanceAAMP::SetVideoMute(bool muted)
{
        mStreamSink->SetVideoMute(muted);
}
 
/**
 *   @brief Enable/ Disable Subtitles.
 *
 *   @param  muted - true to disable subtitles, false to enable subtitles.
 */
void PrivateInstanceAAMP::SetSubtitleMute(bool muted)
{
        mStreamSink->SetSubtitleMute(muted);
}
 
/**
 *   @brief Set Audio Volume.
 *
 *   @param  volume - Minimum 0, maximum 100.
 */
void PrivateInstanceAAMP::SetAudioVolume(int volume)
{
        mStreamSink->SetAudioVolume(volume);
}
 
/**
 * @brief abort ongoing downloads and returns error on future downloads
 * called while stopping fragment collector thread
 */
void PrivateInstanceAAMP::DisableDownloads(void)
{
        pthread_mutex_lock(&mLock);
        mDownloadsEnabled = false;
        pthread_cond_broadcast(&mDownloadsDisabled);
        pthread_mutex_unlock(&mLock);
}
 
/**
 * @brief Check if track can inject data into GStreamer.
 */
bool PrivateInstanceAAMP::DownloadsAreEnabled(void)
{
        return mDownloadsEnabled; // needs mutex protection?
}
 
/**
 * @brief Enable downloads after aamp_DisableDownloads.
 * Called after stopping fragment collector thread
 */
void PrivateInstanceAAMP::EnableDownloads()
{
        pthread_mutex_lock(&mLock);
        mDownloadsEnabled = true;
        pthread_mutex_unlock(&mLock);
}
 
/**
 * @brief Sleep until timeout is reached or interrupted
 */
void PrivateInstanceAAMP::InterruptableMsSleep(int timeInMs)
{
        if (timeInMs > 0)
        {
                struct timespec ts;
                int ret;
                ts = aamp_GetTimespec(timeInMs);
                pthread_mutex_lock(&mLock);
                if (mDownloadsEnabled)
                {
                        ret = pthread_cond_timedwait(&mDownloadsDisabled, &mLock, &ts);
                        if (0 == ret)
                        {
                                //AAMPLOG_WARN("sleep interrupted!");
                        }
                        else if (ETIMEDOUT != ret)
                        {
                                AAMPLOG_WARN("sleep - condition wait failed %s", strerror(ret));
                        }
                }
                pthread_mutex_unlock(&mLock);
        }
}
 
/**
 * @brief Get asset duration in milliseconds
 */
long long PrivateInstanceAAMP::GetDurationMs()
{
        if (mMediaFormat == eMEDIAFORMAT_PROGRESSIVE)
        {
                long long ms = mStreamSink->GetDurationMilliseconds();
                durationSeconds = ms/1000.0;
                return ms;
        }
        else
        {
                return (long long)(durationSeconds*1000.0);
        }
}
 
/**
 *   @brief Get asset duration in milliseconds
 *   For VIDEO TAG Based playback, mainly when
 *   aamp is used as plugin
 */
long long PrivateInstanceAAMP::DurationFromStartOfPlaybackMs()
{
        if (mMediaFormat == eMEDIAFORMAT_PROGRESSIVE)
        {
                long long ms = mStreamSink->GetDurationMilliseconds();
                durationSeconds = ms/1000.0;
                return ms;
        }
        else
        {
                if( mIsLive )
                {
                        long long ms = (culledSeconds * 1000.0) + (durationSeconds * 1000.0);
                        return ms;
                }
                else
                {
                        return (long long)(durationSeconds*1000.0);
                }
        }
}
 
/**
 *   @brief Get current stream position
 */
long long PrivateInstanceAAMP::GetPositionMs()
{
        const auto prevPositionInfo = mPrevPositionMilliseconds.GetInfo();
        double seek_pos_seconds_copy = seek_pos_seconds;
        if(prevPositionInfo.isPositionValid(seek_pos_seconds_copy))
        {
                return prevPositionInfo.getPosition();
        }
        else
        {
                if(prevPositionInfo.isPopulated())
                {
                        //Since LLAMA-7124 previous position values calculated using different values of seek_pos_seconds are considered invalid.
                        AAMPLOG_WARN("prev-pos-ms (%lld) is invalid. seek_pos_seconds = %f, seek_pos_seconds when prev-pos-ms was stored = %f.",prevPositionInfo.getPosition(), seek_pos_seconds_copy, prevPositionInfo.getSeekPositionSec());
                }
                return GetPositionMilliseconds();
        }
}
 
bool PrivateInstanceAAMP::LockGetPositionMilliseconds()
{
        std::lock_guard<std::mutex> functionLock{mGetPositionMillisecondsMutexHard};
        if(!mGetPositionMillisecondsMutexSoft.try_lock())
        {
                //In situations that could have deadlocked, continue & make a log entry instead.
                AAMPLOG_ERR("Failed to acquire lock.");
                return false;
        }
        return true;
}
 
void PrivateInstanceAAMP::UnlockGetPositionMilliseconds()
{
        std::lock_guard<std::mutex> functionLock{mGetPositionMillisecondsMutexHard};
 
        //Avoid the posibility of unlocking an unlocked mutex (undefined behaviour).
        if(mGetPositionMillisecondsMutexSoft.try_lock())
        {
                AAMPLOG_WARN("Acquire lock (unexpected condition unless a previous lock has failed or there is a missing call to LockGetPositionMilliseconds()).");
        }
        mGetPositionMillisecondsMutexSoft.unlock();
}
 
/**
 * @brief Get current stream playback position in milliseconds
 */
long long PrivateInstanceAAMP::GetPositionMilliseconds()
{
        /* LLAMA-7124
         * Ideally between LockGetPositionMilliseconds() & UnlockGetPositionMilliseconds() this function would be blocked
         * (i.e. all mGetPositionMillisecondsMutexSoft.try_lock() replaced with lock()) this would
         * ensure mState & seek_pos_seconds are syncronised during this function.
         * however it is difficult to be certain that this would not result in a deadlock.
         * Instead raise an error and potentially return a spurious position in cases that could have deadlocked.
        */
        std::lock_guard<std::mutex> functionLock{mGetPositionMillisecondsMutexHard};
        bool locked = mGetPositionMillisecondsMutexSoft.try_lock();
        if(!locked)
        {
                AAMPLOG_ERR("Failed to acquire lock. A spurious position value may be calculated.");
        }
 
        //LLAMA-7124 - Local copy to avoid race. LLAMA-8500 will consider further improvements to the thread safety of this variable.
        double seek_pos_seconds_copy = seek_pos_seconds;
        long long positionMiliseconds = seek_pos_seconds_copy != -1 ? seek_pos_seconds_copy * 1000.0 : 0.0;
 
        //LLAMA-7124 - Local copy to avoid race. LLAMA-8500 will consider further improvements to the thread safety of this variable.
        auto trickStartUTCMS_copy = trickStartUTCMS;
        AAMPLOG_TRACE("trickStartUTCMS=%lld", trickStartUTCMS_copy);
        if (trickStartUTCMS_copy >= 0)
        {
                //LLAMA-7124 - Local copy to avoid race. LLAMA-8500 will consider further improvements to the thread safety of this variable.
                auto rate_copy = rate;
                AAMPLOG_TRACE("rate=%f", rate_copy);
 
                //DELIA-39530 - Audio only playback is un-tested. Hence disabled for now
                if (ISCONFIGSET_PRIV(eAAMPConfig_EnableGstPositionQuery) && !ISCONFIGSET_PRIV(eAAMPConfig_AudioOnlyPlayback) && !mAudioOnlyPb)
        {
                        auto gstPosition = mStreamSink->GetPositionMilliseconds();
 
                        /* LLAMA-7124 - Prevent spurious values being returned by this function during seek.
                         * This fix is similar to LLAMA-8369 but applied at this lower level because 
                         * PrivateInstanceAAMP::GetPositionMilliseconds() is called elsewhere e.g. setting seek_pos_seconds
                         * note for this to work correctly mState and seek_pos_seconds must updated atomically othewise
                         * spuriously low (mState = eSTATE_SEEKING before seek_pos_seconds updated) or 
                         * spuriously high (seek_pos_seconds updated before mState = eSTATE_SEEKING) values could result.
                         */
                        if(mState == eSTATE_SEEKING)
                        {
                                if(gstPosition!=0)
                                {
                                        AAMPLOG_WARN("Ignoring gst position of %ldms and using seek_pos_seconds only until seek completes.", gstPosition);
                                }
                        }
                        else
                        {
                                positionMiliseconds += gstPosition;
                        }
                }
                else
                {
                        long long elapsedTime = aamp_GetCurrentTimeMS() - trickStartUTCMS_copy;
                        positionMiliseconds += (((elapsedTime > 1000) ? elapsedTime : 0) * rate_copy);
                }
                if(AAMP_NORMAL_PLAY_RATE == rate_copy)
                {
                        /*LLAMA-7124 - Standardised & tightened validity checking of previous position to 
                          avoid spurious 'restore prev-pos as current-pos!!' around seeks*/
                        const auto prevPositionInfo = mPrevPositionMilliseconds.GetInfo();
                        if(prevPositionInfo.isPositionValid(seek_pos_seconds_copy))
                        {
                                long long diff = positionMiliseconds - prevPositionInfo.getPosition();
 
                                if ((diff > MAX_DIFF_BETWEEN_PTS_POS_MS) || (diff < 0))
                                {
                                        AAMPLOG_WARN("diff %lld prev-pos-ms %lld current-pos-ms %lld, restore prev-pos as current-pos!!", diff, prevPositionInfo.getPosition(), positionMiliseconds);
                                        positionMiliseconds = prevPositionInfo.getPosition();
                                }
                        }
                        else if(prevPositionInfo.isPopulated())
                        {
                                //Since LLAMA-7124 previous position values calculated using different values of seek_pos_seconds are considered invalid.
                                AAMPLOG_WARN("prev-pos-ms (%lld) is invalid. seek_pos_seconds = %f, seek_pos_seconds when prev-pos-ms was stored = %f.",prevPositionInfo.getPosition(), seek_pos_seconds_copy, prevPositionInfo.getSeekPositionSec());
                        }
                }
 
                if (positionMiliseconds < 0)
                {
                        AAMPLOG_WARN("Correcting positionMiliseconds %lld to zero", positionMiliseconds);
                        positionMiliseconds = 0;
                }
                else
                {
                        if (!mIsLiveStream)
                        {
                                long long durationMs  = GetDurationMs();
                                if(positionMiliseconds > durationMs)
                                {
                                        AAMPLOG_WARN("Correcting positionMiliseconds %lld to duration %lld", positionMiliseconds, durationMs);
                                        positionMiliseconds = durationMs;
                                }
                        }
                        else
                        {
                                long long tsbEndMs = GetDurationMs() + (culledSeconds * 1000.0);
                                if(positionMiliseconds > tsbEndMs)
                                {
                                        AAMPLOG_WARN("Correcting positionMiliseconds %lld to tsbEndMs %lld", positionMiliseconds, tsbEndMs);
                                        positionMiliseconds = tsbEndMs;
                                }
                        }
                }
        }
 
        AAMPLOG_TRACE("Returning Position as %lld (seek_pos_seconds = %f) and updating previous position.", positionMiliseconds, seek_pos_seconds_copy);
        mPrevPositionMilliseconds.Update(positionMiliseconds ,seek_pos_seconds_copy);
 
        if(locked)
        {
                mGetPositionMillisecondsMutexSoft.unlock();
        }
 
        return positionMiliseconds;
}
 
/**
 * @brief  API to send audio/video stream into the sink.
 */
void PrivateInstanceAAMP::SendStreamCopy(MediaType mediaType, const void *ptr, size_t len, double fpts, double fdts, double fDuration)
{
        mStreamSink->SendCopy(mediaType, ptr, len, fpts, fdts, fDuration);
}
 
/**
 * @brief  API to send audio/video stream into the sink.
 */
void PrivateInstanceAAMP::SendStreamTransfer(MediaType mediaType, GrowableBuffer* buffer, double fpts, double fdts, double fDuration, bool initFragment)
{
        if( mStreamSink->SendTransfer(mediaType, buffer->ptr, buffer->len, fpts, fdts, fDuration, initFragment) )
        {
                aamp_TransferMemory(buffer->ptr);
        }
        else
        { // unable to transfer - free up the buffer we were passed.
                aamp_Free(buffer);
        }
        memset(buffer, 0x00, sizeof(GrowableBuffer));
}
 
/**
 * @brief Setting the stream sink
 */
void PrivateInstanceAAMP::SetStreamSink(StreamSink* streamSink)
{
        mStreamSink = streamSink;
}
 
/**
 * @brief Checking if the stream is live or not
 */
bool PrivateInstanceAAMP::IsLive()
{
        return mIsLive;
}
 
/**
 * @brief Check if audio playcontext creation skipped for Demuxed HLS file.
 * @retval true if playcontext creation skipped, false if not.
 */
bool PrivateInstanceAAMP::IsAudioPlayContextCreationSkipped()
{
        return mIsAudioContextSkipped;
}
 
/**
 * @brief Check if stream is live
 */
bool PrivateInstanceAAMP::IsLiveStream()
{
        return mIsLiveStream;
}
 
/**
 * @brief Stop playback and release resources.
 *
 */
void PrivateInstanceAAMP::Stop()
{
        // Clear all the player events in the queue and sets its state to RELEASED as everything is done
        mEventManager->SetPlayerState(eSTATE_RELEASED);
        mEventManager->FlushPendingEvents();
 
        pthread_mutex_lock(&gMutex);
        auto iter = std::find_if(std::begin(gActivePrivAAMPs), std::end(gActivePrivAAMPs), [this](const gActivePrivAAMP_t& el)
        {
                return el.pAAMP == this;
        });
 
        if(iter != gActivePrivAAMPs.end())
        {
                if (iter->reTune && mIsRetuneInProgress)
                {
                        // Wait for any ongoing re-tune operation to complete
                        pthread_cond_wait(&gCond, &gMutex);
                }
                iter->reTune = false;
        }
        pthread_mutex_unlock(&gMutex);
 
        if (mAutoResumeTaskPending)
        {
                RemoveAsyncTask(mAutoResumeTaskId);
                mAutoResumeTaskId = AAMP_TASK_ID_INVALID;
                mAutoResumeTaskPending = false;
        }
 
        DisableDownloads();
        UnblockWaitForDiscontinuityProcessToComplete();
 
        // Stopping the playback, release all DRM context
        if (mpStreamAbstractionAAMP)
        {
#if defined(AAMP_MPD_DRM) || defined(AAMP_HLS_DRM)
                if (mDRMSessionManager)
                {
                        mDRMSessionManager->setLicenseRequestAbort(true);
                }
#endif
                mpStreamAbstractionAAMP->Stop(true);
                if (HasSidecarData())
                { // has sidecar data
                        mpStreamAbstractionAAMP->ResetSubtitle();
                }
                //Deleting mpStreamAbstractionAAMP here will prevent the extra stop call in TeardownStream()
                //and will avoid enableDownlaod() call being made unnecessarily
                SAFE_DELETE(mpStreamAbstractionAAMP);
        }
 
        TeardownStream(true);
 
        for(int i=0; i<eMEDIATYPE_DEFAULT; i++)
        {
                FlushLastId3Data((MediaType)i);
        }
        pthread_mutex_lock(&mEventLock);
        if (mPendingAsyncEvents.size() > 0)
        {
                AAMPLOG_WARN("PrivateInstanceAAMP: mPendingAsyncEvents.size - %lu", mPendingAsyncEvents.size());
                for (std::map<guint, bool>::iterator it = mPendingAsyncEvents.begin(); it != mPendingAsyncEvents.end(); it++)
                {
                        if (it->first != 0)
                        {
                                if (it->second)
                                {
                                        AAMPLOG_WARN("PrivateInstanceAAMP: remove id - %d", (int) it->first);
                                        g_source_remove(it->first);
                                }
                                else
                                {
                                        AAMPLOG_WARN("PrivateInstanceAAMP: Not removing id - %d as not pending", (int) it->first);
                                }
                        }
                }
                mPendingAsyncEvents.clear();
        }
        pthread_mutex_unlock(&mEventLock);
 
        // Streamer threads are stopped when we reach here, thread synchronization not required
        if (timedMetadata.size() > 0)
        {
                timedMetadata.clear();
        }
        mFailureReason="";
 
 
        // LLAMA-7124 - explicitly invalidate previous position for consistency with previous code
        mPrevPositionMilliseconds.Invalidate();
        seek_pos_seconds = -1;
        culledSeconds = 0;
        mIsLiveStream = false;
        durationSeconds = 0;
        mProgressReportOffset = -1;
        rate = 1;
        // Set the state to eSTATE_IDLE
        // directly setting state variable . Calling SetState will trigger event :(
        mState = eSTATE_IDLE;
  
        mSeekOperationInProgress = false;
        mTrickplayInProgress = false;
        mMaxLanguageCount = 0; // reset language count
        //mPreferredAudioTrack = AudioTrackInfo(); // reset
        mPreferredTextTrack = TextTrackInfo(); // reset
        // send signal to any thread waiting for play
        pthread_mutex_lock(&mMutexPlaystart);
        pthread_cond_broadcast(&waitforplaystart);
        pthread_mutex_unlock(&mMutexPlaystart);
        if(mPreCachePlaylistThreadFlag)
        {
                pthread_join(mPreCachePlaylistThreadId,NULL);
                mPreCachePlaylistThreadFlag=false;
                mPreCachePlaylistThreadId = 0;
        }
        getAampCacheHandler()->StopPlaylistCache();
 
 
        if (pipeline_paused)
        {
                pipeline_paused = false;
        }
 
        //temporary hack for peacock
        if (STARTS_WITH_IGNORE_CASE(mAppName.c_str(), "peacock"))
        {
                SAFE_DELETE(mAampCacheHandler);
 
#if defined(AAMP_MPD_DRM) || defined(AAMP_HLS_DRM)
                SAFE_DELETE(mDRMSessionManager);
#endif
        }
 
        SAFE_DELETE(mCdaiObject);
 
#if 0
        /* Clear the session data*/
        if(!mSessionToken.empty()){
                mSessionToken.clear();
        }
#endif
 
        EnableDownloads();
}
 
/**
 * @brief SaveTimedMetadata Function to store Metadata for bulk reporting during Initialization 
 */
void PrivateInstanceAAMP::SaveTimedMetadata(long long timeMilliseconds, const char* szName, const char* szContent, int nb, const char* id, double durationMS)
{
        std::string content(szContent, nb);
        timedMetadata.push_back(TimedMetadata(timeMilliseconds, std::string((szName == NULL) ? "" : szName), content, std::string((id == NULL) ? "" : id), durationMS));
}
 
/**
 * @brief SaveNewTimedMetadata Function to store Metadata and reporting event one by one after DRM Initialization
 */
void PrivateInstanceAAMP::SaveNewTimedMetadata(long long timeMilliseconds, const char* szName, const char* szContent, int nb, const char* id, double durationMS)
{
        std::string content(szContent, nb);
        timedMetadataNew.push_back(TimedMetadata(timeMilliseconds, std::string((szName == NULL) ? "" : szName), content, std::string((id == NULL) ? "" : id), durationMS));
}
 
/**
 * @brief Report timed metadata Function to send timedMetadata 
 */
void PrivateInstanceAAMP::ReportTimedMetadata(bool init)
{
        bool bMetadata = ISCONFIGSET_PRIV(eAAMPConfig_BulkTimedMetaReport);
        if(bMetadata && init && IsNewTune())
        {
                ReportBulkTimedMetadata();
        }
        else
        {
                std::vector<TimedMetadata>::iterator iter;
                mTimedMetadataStartTime = NOW_STEADY_TS_MS ;
                for (iter = timedMetadataNew.begin(); iter != timedMetadataNew.end(); iter++)
                {
                        ReportTimedMetadata(iter->_timeMS, iter->_name.c_str(), iter->_content.c_str(), iter->_content.size(), init, iter->_id.c_str(), iter->_durationMS);
                }
                timedMetadataNew.clear();
                mTimedMetadataDuration = (NOW_STEADY_TS_MS - mTimedMetadataStartTime);
        }       
}
 
/**
 * @brief Report bulk timedMetadata Function to send bulk timedMetadata in json format 
 */
void PrivateInstanceAAMP::ReportBulkTimedMetadata()
{
        mTimedMetadataStartTime = NOW_STEADY_TS_MS;
        std::vector<TimedMetadata>::iterator iter;
        if(ISCONFIGSET_PRIV(eAAMPConfig_EnableSubscribedTags) && timedMetadata.size())
        {
                AAMPLOG_INFO("Sending bulk Timed Metadata");
 
                cJSON *root;
                cJSON *item;
                root = cJSON_CreateArray();
                if(root)
                {
                        for (iter = timedMetadata.begin(); iter != timedMetadata.end(); iter++)
                        {
                                cJSON_AddItemToArray(root, item = cJSON_CreateObject());
                                cJSON_AddStringToObject(item, "name", iter->_name.c_str());
                                cJSON_AddStringToObject(item, "id", iter->_id.c_str());
                                cJSON_AddNumberToObject(item, "timeMs", iter->_timeMS);
                                cJSON_AddNumberToObject (item, "durationMs",iter->_durationMS);
                                cJSON_AddStringToObject(item, "data", iter->_content.c_str());
                        }
 
                        char* bulkData = cJSON_PrintUnformatted(root);
                        if(bulkData)
                        {
                                BulkTimedMetadataEventPtr eventData = std::make_shared<BulkTimedMetadataEvent>(std::string(bulkData));
                                AAMPLOG_INFO("Sending bulkTimedData");
                                if (ISCONFIGSET_PRIV(eAAMPConfig_MetadataLogging))
                                {
                                        AAMPLOG_INFO("bulkTimedData : %s", bulkData);
                                }
                                // Sending BulkTimedMetaData event as synchronous event.
                                // SCTE35 events are async events in TimedMetadata, and this event is sending only from HLS
                                mEventManager->SendEvent(eventData);
                                free(bulkData);
                        }
                        cJSON_Delete(root);
                }
                mTimedMetadataDuration = (NOW_STEADY_TS_MS - mTimedMetadataStartTime);
        }
}
 
/**
 * @brief Report timed metadata Function to send timedMetadata events
 */
void PrivateInstanceAAMP::ReportTimedMetadata(long long timeMilliseconds, const char *szName, const char *szContent, int nb, bool bSyncCall, const char *id, double durationMS)
{
        std::string content(szContent, nb);
        bool bFireEvent = false;
 
        // Check if timedMetadata was already reported
        std::vector<TimedMetadata>::iterator i;
        bool ignoreMetaAdd = false;
 
        for (i = timedMetadata.begin(); i != timedMetadata.end(); i++)
        {
                if ((timeMilliseconds >= i->_timeMS-1000 && timeMilliseconds <= i->_timeMS+1000 ))
                {
                        if((i->_name.compare(szName) == 0) && (i->_content.compare(content) == 0))
                        {
                                // Already same exists , ignore
                                ignoreMetaAdd = true;
                                break;
                        }
                        else
                        {
                                continue;
                        }
                }
                else if (i->_timeMS < timeMilliseconds)
                {
                        // move to next entry
                        continue;
                }               
                else if (i->_timeMS > timeMilliseconds)
                {
                        break;
                }               
        }
 
        if(!ignoreMetaAdd) 
        {
                bFireEvent = true;
                if(i == timedMetadata.end())
                {
                        // Comes here for
                        // 1.No entry in the table
                        // 2.Entries available which is only having time < NewMetatime
                        timedMetadata.push_back(TimedMetadata(timeMilliseconds, szName, content, id, durationMS));
                }
                else
                {
                        // New entry in between saved entries.
                        // i->_timeMS >= timeMilliseconds && no similar entry in table
                        timedMetadata.insert(i, TimedMetadata(timeMilliseconds, szName, content, id, durationMS));
                }
        }
 
 
        if (bFireEvent)
        {
                //DELIA-40019: szContent should not contain any tag name and ":" delimiter. This is not checked in JS event listeners
                TimedMetadataEventPtr eventData = std::make_shared<TimedMetadataEvent>(((szName == NULL) ? "" : szName), ((id == NULL) ? "" : id), timeMilliseconds, durationMS, content);
 
                if (ISCONFIGSET_PRIV(eAAMPConfig_MetadataLogging))
                {
                        AAMPLOG_WARN("aamp timedMetadata: [%ld] '%s'", (long)(timeMilliseconds), content.c_str());
                }
 
                if (!bSyncCall)
                {
                        mEventManager->SendEvent(eventData,AAMP_EVENT_ASYNC_MODE);
                }
                else
                {
                        mEventManager->SendEvent(eventData,AAMP_EVENT_SYNC_MODE);
                }
        }
}
 
 
/**
 * @brief Report content gap events
 */
void PrivateInstanceAAMP::ReportContentGap(long long timeMilliseconds, std::string id, double durationMS)
{
        bool bFireEvent = false;
        bool ignoreMetaAdd = false;
        // Check if contentGap was already reported
        std::vector<ContentGapInfo>::iterator iter;
 
        for (iter = contentGaps.begin(); iter != contentGaps.end(); iter++)
        {
                if ((timeMilliseconds >= iter->_timeMS-1000 && timeMilliseconds <= iter->_timeMS+1000 ))
                {
                        if(iter->_id == id)
                        {
                                // Already same exists , ignore if periodGap information is complete.
                                if(iter->_complete)
                                {
                                        ignoreMetaAdd = true;
                                        break;
                                }
                                else
                                {
                                        if(durationMS >= 0)
                                        {
                                                // New request with duration, mark complete and report it.
                                                iter->_durationMS = durationMS;
                                                iter->_complete = true;
                                        }
                                        else
                                        {
                                                // Duplicate report request, already processed
                                                ignoreMetaAdd = true;
                                                break;
                                        }
                                }
                        }
                        else
                        {
                                continue;
                        }
                }
                else if (iter->_timeMS < timeMilliseconds)
                {
                        // move to next entry
                        continue;
                }
                else if (iter->_timeMS > timeMilliseconds)
                {
                        break;
                }
        }
 
        if(!ignoreMetaAdd)
        {
                bFireEvent = true;
                if(iter == contentGaps.end())
                {
                        contentGaps.push_back(ContentGapInfo(timeMilliseconds, id, durationMS));
                }
                else
                {
                        contentGaps.insert(iter, ContentGapInfo(timeMilliseconds, id, durationMS));
                }
        }
 
 
        if (bFireEvent)
        {
                ContentGapEventPtr eventData = std::make_shared<ContentGapEvent>(timeMilliseconds, durationMS);
                AAMPLOG_INFO("aamp contentGap: start: %lld duration: %ld", timeMilliseconds, (long) durationMS);
                mEventManager->SendEvent(eventData);
        }
}
 
/**
 *   @brief Initialize CC after first frame received
 *          Sends CC handle event to listeners when first frame receives or video_dec handle rests
 */
void PrivateInstanceAAMP::InitializeCC()
{
#ifdef AAMP_STOP_SINK_ON_SEEK
        /*Do not send event on trickplay as CC is not enabled*/
        if (AAMP_NORMAL_PLAY_RATE != rate)
        {
                AAMPLOG_WARN("PrivateInstanceAAMP: not sending cc handle as rate = %f", rate);
                return;
        }
#endif
        if (mStreamSink != NULL)
        {
#ifdef AAMP_CC_ENABLED
                if (ISCONFIGSET_PRIV(eAAMPConfig_NativeCCRendering))
                {
                        AampCCManager::GetInstance()->Init((void *)mStreamSink->getCCDecoderHandle());
 
                        int overrideCfg;
                        GETCONFIGVALUE_PRIV(eAAMPConfig_CEAPreferred,overrideCfg);
                        if (overrideCfg == 0)
                        {
                            AAMPLOG_WARN("PrivateInstanceAAMP: CC format override to 608 present, selecting 608CC");
                            AampCCManager::GetInstance()->SetTrack("CC1");
                        }
 
                }
                else
#endif
                {
                        CCHandleEventPtr event = std::make_shared<CCHandleEvent>(mStreamSink->getCCDecoderHandle());
                        mEventManager->SendEvent(event);
                }
        }
}
 
 
/**
 *  @brief Notify first frame is displayed. Sends CC handle event to listeners.
 */
void PrivateInstanceAAMP::NotifyFirstFrameReceived()
{
        // In the middle of stop processing we can receive state changing callback (xione-7331)
        PrivAAMPState state;
        GetState(state);
        if (state == eSTATE_IDLE)
        {
                AAMPLOG_WARN( "skipped as in IDLE state" );
                return;
        }
        
        // If mFirstVideoFrameDisplayedEnabled, state will be changed in NotifyFirstVideoDisplayed()
        if(!mFirstVideoFrameDisplayedEnabled)
        {
                SetState(eSTATE_PLAYING);
        }
        pthread_mutex_lock(&mMutexPlaystart);
        pthread_cond_broadcast(&waitforplaystart);
        pthread_mutex_unlock(&mMutexPlaystart);
 
        if (eTUNED_EVENT_ON_GST_PLAYING == GetTuneEventConfig(IsLive()))
        {
                // This is an idle callback, so we can sent event synchronously
                if (SendTunedEvent())
                {
                        AAMPLOG_WARN("aamp: - sent tune event on Tune Completion.");
                }
        }
        InitializeCC();
}
 
/**
 *   @brief Signal discontinuity of track.
 *   Called from StreamAbstractionAAMP to signal discontinuity
 */
bool PrivateInstanceAAMP::Discontinuity(MediaType track, bool setDiscontinuityFlag)
{
        bool ret;
 
        if (setDiscontinuityFlag)
        {
                ret = true;
        }
        else
        {
                SyncBegin();
                ret = mStreamSink->Discontinuity(track);
                SyncEnd();
        }
 
        if (ret)
        {
                mProcessingDiscontinuity[track] = true;
        }
        return ret;
}
 
/**
 * @brief Schedules retune or discontinuity processing based on state.
 */
void PrivateInstanceAAMP::ScheduleRetune(PlaybackErrorType errorType, MediaType trackType)
{
        if (AAMP_NORMAL_PLAY_RATE == rate && ContentType_EAS != mContentType)
        {
                PrivAAMPState state;
                GetState(state);
                if (((state != eSTATE_PLAYING) && (eGST_ERROR_VIDEO_BUFFERING != errorType)) || mSeekOperationInProgress)
                {
                        AAMPLOG_WARN("PrivateInstanceAAMP: Not processing reTune since state = %d, mSeekOperationInProgress = %d",
                                                state, mSeekOperationInProgress);
                        return;
                }
 
                pthread_mutex_lock(&gMutex);
                if (this->mIsRetuneInProgress)
                {
                        AAMPLOG_WARN("PrivateInstanceAAMP:: Already Retune inprogress");
                        pthread_mutex_unlock(&gMutex);
                        return;
                }
                pthread_mutex_unlock(&gMutex);
 
                /*If underflow is caused by a discontinuity processing, continue playback from discontinuity*/
                // If discontinuity process in progress, skip further processing
                // DELIA-46559 Since discontinuity flags are reset a bit earlier, additional checks added below to check if discontinuity processing in progress
                pthread_mutex_lock(&mLock);
                if ((errorType != eGST_ERROR_PTS) &&
                                (IsDiscontinuityProcessPending() || mDiscontinuityTuneOperationId != 0 || mDiscontinuityTuneOperationInProgress))
                {
                        if (mDiscontinuityTuneOperationId != 0 || mDiscontinuityTuneOperationInProgress)
                        {
                                AAMPLOG_WARN("PrivateInstanceAAMP: Discontinuity Tune handler already spawned(%d) or inprogress(%d)",
                                        mDiscontinuityTuneOperationId, mDiscontinuityTuneOperationInProgress);
                                pthread_mutex_unlock(&mLock);
                                return;
                        }
                        mDiscontinuityTuneOperationId = ScheduleAsyncTask(PrivateInstanceAAMP_ProcessDiscontinuity, (void *)this, "PrivateInstanceAAMP_ProcessDiscontinuity");
                        pthread_mutex_unlock(&mLock);
 
                        AAMPLOG_WARN("PrivateInstanceAAMP: Underflow due to discontinuity handled");
                        return;
                }
 
                pthread_mutex_unlock(&mLock);
 
                if (mpStreamAbstractionAAMP && mpStreamAbstractionAAMP->IsStreamerStalled())
                {
                        AAMPLOG_WARN("PrivateInstanceAAMP: Ignore reTune due to playback stall");
                        return;
                }
                else if (!ISCONFIGSET_PRIV(eAAMPConfig_InternalReTune))
                {
                        AAMPLOG_WARN("PrivateInstanceAAMP: Ignore reTune as disabled in configuration");
                        return;
                }
 
                MediaTrack* mediaTrack = (mpStreamAbstractionAAMP != NULL) ? (mpStreamAbstractionAAMP->GetMediaTrack((TrackType)trackType)) : NULL;
                
                if((ISCONFIGSET_PRIV(eAAMPConfig_ReportBufferEvent)) &&
                (errorType == eGST_ERROR_UNDERFLOW) &&
                (trackType == eMEDIATYPE_VIDEO) &&
                (mediaTrack) &&
                (mediaTrack->GetBufferStatus() == BUFFER_STATUS_RED))
                {
                        SendBufferChangeEvent(true);  // Buffer state changed, buffer Under flow started
                        if (!pipeline_paused &&  !PausePipeline(true, true))
                        {
                                        AAMPLOG_ERR("Failed to pause the Pipeline");
                        }
                }
 
                const char* errorString  =  (errorType == eGST_ERROR_PTS) ? "PTS ERROR" :
                                                                        (errorType == eGST_ERROR_UNDERFLOW) ? "Underflow" :
                                                                        (errorType == eSTALL_AFTER_DISCONTINUITY) ? "Stall After Discontinuity" :
                                                                        (errorType == eDASH_LOW_LATENCY_MAX_CORRECTION_REACHED)?"LL DASH Max Correction Reached":
                                                                        (errorType == eDASH_LOW_LATENCY_INPUT_PROTECTION_ERROR)?"LL DASH Input Protection Error":
                                                                        (errorType == eDASH_RECONFIGURE_FOR_ENC_PERIOD)?"Enrypted period found":
                                                                        (errorType == eGST_ERROR_GST_PIPELINE_INTERNAL) ? "GstPipeline Internal Error" : "STARTTIME RESET";
 
                SendAnomalyEvent(ANOMALY_WARNING, "%s %s", (trackType == eMEDIATYPE_VIDEO ? "VIDEO" : "AUDIO"), errorString);
                bool activeAAMPFound = false;
                pthread_mutex_lock(&gMutex);
                for (std::list<gActivePrivAAMP_t>::iterator iter = gActivePrivAAMPs.begin(); iter != gActivePrivAAMPs.end(); iter++)
                {
                        if (this == iter->pAAMP)
                        {
                                gActivePrivAAMP_t *gAAMPInstance = &(*iter);
                                if (gAAMPInstance->reTune)
                                {
                                        AAMPLOG_WARN("PrivateInstanceAAMP: Already scheduled");
                                }
                                else
                                {
                                        if(eGST_ERROR_PTS == errorType || eGST_ERROR_UNDERFLOW == errorType)
                                        {
                                                long long now = aamp_GetCurrentTimeMS();
                                                long long lastErrorReportedTimeMs = lastUnderFlowTimeMs[trackType];
                                                int ptsErrorThresholdValue = 0;
                                                GETCONFIGVALUE_PRIV(eAAMPConfig_PTSErrorThreshold,ptsErrorThresholdValue);
                                                if (lastErrorReportedTimeMs)
                                                {
                                                        bool isRetuneRequried = false;
                                                        long long diffMs = (now - lastErrorReportedTimeMs);
                                                        if(GetLLDashServiceData()->lowLatencyMode )
                                                        {
                                                                if (diffMs < AAMP_MAX_TIME_LL_BW_UNDERFLOWS_TO_TRIGGER_RETUNE_MS)
                                                                {
                                                                        isRetuneRequried = true;
                                                                }
                                                        }
                                                        else
                                                        {
                                                                if (diffMs < AAMP_MAX_TIME_BW_UNDERFLOWS_TO_TRIGGER_RETUNE_MS)
                                                                {
                                                                        isRetuneRequried = true;
                                                                }
                                                        }
                                                        if(isRetuneRequried)
                                                        {
                                                                gAAMPInstance->numPtsErrors++;
                                                                if (gAAMPInstance->numPtsErrors >= ptsErrorThresholdValue)
                                                                {
                                                                        AAMPLOG_WARN("PrivateInstanceAAMP: numPtsErrors %d, ptsErrorThreshold %d",
                                                                        gAAMPInstance->numPtsErrors, ptsErrorThresholdValue);   
                                                                        gAAMPInstance->numPtsErrors = 0;
                                                                        gAAMPInstance->reTune = true;
                                                                        AAMPLOG_WARN("PrivateInstanceAAMP: Schedule Retune. diffMs %lld < threshold %lld",
                                                                                diffMs, GetLLDashServiceData()->lowLatencyMode?
                                                                                AAMP_MAX_TIME_LL_BW_UNDERFLOWS_TO_TRIGGER_RETUNE_MS:AAMP_MAX_TIME_BW_UNDERFLOWS_TO_TRIGGER_RETUNE_MS);
                                                                        AdditionalTuneFailLogEntries();
                                                                        ScheduleAsyncTask(PrivateInstanceAAMP_Retune, (void *)this, "PrivateInstanceAAMP_Retune");
                                                                }
                                                        }
                                                        else
                                                        {
                                                                gAAMPInstance->numPtsErrors = 0;
                                                                AAMPLOG_WARN("PrivateInstanceAAMP: Not scheduling reTune since (diff %lld > threshold %lld) numPtsErrors %d, ptsErrorThreshold %d.",
                                                                        diffMs, GetLLDashServiceData()->lowLatencyMode?
                                                                        AAMP_MAX_TIME_LL_BW_UNDERFLOWS_TO_TRIGGER_RETUNE_MS:AAMP_MAX_TIME_BW_UNDERFLOWS_TO_TRIGGER_RETUNE_MS,
                                                                        gAAMPInstance->numPtsErrors, ptsErrorThresholdValue);
                                                        }
                                                }
                                                else
                                                {
                                                        gAAMPInstance->numPtsErrors = 0;
                                                        AAMPLOG_WARN("PrivateInstanceAAMP: Not scheduling reTune since first %s.", errorString);
                                                }
                                                lastUnderFlowTimeMs[trackType] = now;
                                        }
                                        else
                                        {
                                                AAMPLOG_WARN("PrivateInstanceAAMP: Schedule Retune errorType %d error %s", errorType, errorString);
                                                gAAMPInstance->reTune = true;
                                                AdditionalTuneFailLogEntries();
                                                ScheduleAsyncTask(PrivateInstanceAAMP_Retune, (void *)this, "PrivateInstanceAAMP_Retune");
                                        }
                                }
                                activeAAMPFound = true;
                                break;
                        }
                }
                pthread_mutex_unlock(&gMutex);
                if (!activeAAMPFound)
                {
                        AAMPLOG_WARN("PrivateInstanceAAMP: %p not in Active AAMP list", this);
                }
        }
}
 
/**
 * @brief Set player state
 */
void PrivateInstanceAAMP::SetState(PrivAAMPState state)
{
        //bool sentSync = true;
 
        if (mState == state)
        { // noop
                return;
        }
 
        if ( (state == eSTATE_PLAYING || state == eSTATE_BUFFERING || state == eSTATE_PAUSED)
                && mState == eSTATE_SEEKING && (mEventManager->IsEventListenerAvailable(AAMP_EVENT_SEEKED)))
        {
                SeekedEventPtr event = std::make_shared<SeekedEvent>(GetPositionMilliseconds());
                mEventManager->SendEvent(event,AAMP_EVENT_SYNC_MODE);
 
        }
 
        pthread_mutex_lock(&mLock);
        mState = state;
        pthread_mutex_unlock(&mLock);
 
        mScheduler->SetState(mState);
        if (mEventManager->IsEventListenerAvailable(AAMP_EVENT_STATE_CHANGED))
        {
                if (mState == eSTATE_PREPARING)
                {
                        StateChangedEventPtr eventData = std::make_shared<StateChangedEvent>(eSTATE_INITIALIZED);
                        mEventManager->SendEvent(eventData,AAMP_EVENT_SYNC_MODE);
                }
 
                StateChangedEventPtr eventData = std::make_shared<StateChangedEvent>(mState);
                mEventManager->SendEvent(eventData,AAMP_EVENT_SYNC_MODE);
        }
}
 
/**
 * @brief Get player state
 */
void PrivateInstanceAAMP::GetState(PrivAAMPState& state)
{
        pthread_mutex_lock(&mLock);
        state = mState;
        pthread_mutex_unlock(&mLock);
}
 
/**
 *  @brief Add high priority idle task to the gstreamer
 *  @note task shall return 0 to be removed, 1 to be repeated
 */
gint PrivateInstanceAAMP::AddHighIdleTask(IdleTask task, void* arg,DestroyTask dtask)
{
        gint callbackID = g_idle_add_full(G_PRIORITY_HIGH_IDLE, task, (gpointer)arg, dtask);
        return callbackID;
}
 
/**
 *   @brief Check sink cache empty
 */
bool PrivateInstanceAAMP::IsSinkCacheEmpty(MediaType mediaType)
{
        return mStreamSink->IsCacheEmpty(mediaType);
}
 
/**
 * @brief Reset EOS SignalledFlag
 */
void PrivateInstanceAAMP::ResetEOSSignalledFlag()
{
        return mStreamSink->ResetEOSSignalledFlag();
}
 
/**
 * @brief Notify fragment caching complete
 */
void PrivateInstanceAAMP::NotifyFragmentCachingComplete()
{
        pthread_mutex_lock(&mFragmentCachingLock);
        mFragmentCachingRequired = false;
        mStreamSink->NotifyFragmentCachingComplete();
        PrivAAMPState state;
        GetState(state);
        if (state == eSTATE_BUFFERING)
        {
                if(mpStreamAbstractionAAMP)
                {
                        mpStreamAbstractionAAMP->NotifyPlaybackPaused(false);
                }
                SetState(eSTATE_PLAYING);
        }
        pthread_mutex_unlock(&mFragmentCachingLock);
}
 
/**
 * @brief Send tuned event to listeners if required
 */
bool PrivateInstanceAAMP::SendTunedEvent(bool isSynchronous)
{
        bool ret = false;
 
        // Required for synchronising btw audio and video tracks in case of cdmidecryptor
        pthread_mutex_lock(&mLock);
 
        ret = mTunedEventPending;
        mTunedEventPending = false;
 
        pthread_mutex_unlock(&mLock);
 
        if(ret)
        {
                AAMPEventPtr ev = std::make_shared<AAMPEventObject>(AAMP_EVENT_TUNED);
                mEventManager->SendEvent(ev , AAMP_EVENT_SYNC_MODE);
        }
        return ret;
}
 
/**
 *   @brief Send VideoEndEvent
 */
bool PrivateInstanceAAMP::SendVideoEndEvent()
{
        bool ret = false;
        char * strVideoEndJson = NULL;
        // Required for protecting mVideoEnd object
        pthread_mutex_lock(&mLock);
        if(mVideoEnd)
        {
                //Update VideoEnd Data
                if(mTimeAtTopProfile > 0)
                {
                        // Losing milisecons of data in conversion from double to long
                        mVideoEnd->SetTimeAtTopProfile(mTimeAtTopProfile);
                        mVideoEnd->SetTimeToTopProfile(mTimeToTopProfile);
                }
                mVideoEnd->SetTotalDuration(mPlaybackDuration);
 
                // re initialize for next tune collection
                mTimeToTopProfile = 0;
                mTimeAtTopProfile = 0;
                mPlaybackDuration = 0;
                mCurrentLanguageIndex = 0;
 
                //Memory of this string will be deleted after sending event by destructor of AsyncMetricsEventDescriptor
                if(ISCONFIGSET_PRIV(eAAMPConfig_EnableVideoEndEvent) && mEventManager->IsEventListenerAvailable(AAMP_EVENT_REPORT_METRICS_DATA))
                {
                        if(mTSBEnabled)
                        {
                                char* data = GetOnVideoEndSessionStatData();
                                if(data)
                                {
                                        AAMPLOG_INFO("TsbSessionEnd:%s", data);
                                        strVideoEndJson = mVideoEnd->ToJsonString(data);
                                        cJSON_free( data );
                                        data = NULL;
                                }
                        }
                        else
                        {
                                strVideoEndJson = mVideoEnd->ToJsonString();
                        }
                }
                SAFE_DELETE(mVideoEnd);
        }
        mVideoEnd = new CVideoStat(mMediaFormatName[mMediaFormat]);
        mVideoEnd->SetDisplayResolution(mDisplayWidth,mDisplayHeight);
        pthread_mutex_unlock(&mLock);
 
        if(strVideoEndJson)
        {
                AAMPLOG_INFO("VideoEnd:%s", strVideoEndJson);
                MetricsDataEventPtr e = std::make_shared<MetricsDataEvent>(MetricsDataType::AAMP_DATA_VIDEO_END, this->mTraceUUID, strVideoEndJson);
                SendEvent(e,AAMP_EVENT_ASYNC_MODE);
                free(strVideoEndJson);
                ret = true;
        }
        return ret;
}
 
/**
 * @brief updates profile Resolution to VideoStat object
 */
void PrivateInstanceAAMP::UpdateVideoEndProfileResolution(MediaType mediaType, long bitrate, int width, int height)
{
        pthread_mutex_lock(&mLock);
        if(mVideoEnd)
        {
                VideoStatTrackType trackType = VideoStatTrackType::STAT_VIDEO;
                if(mediaType == eMEDIATYPE_IFRAME)
                {
                        trackType = VideoStatTrackType::STAT_IFRAME;
                }
                mVideoEnd->SetProfileResolution(trackType,bitrate,width,height);
        }
        pthread_mutex_unlock(&mLock);
}
 
/**
 *  @brief updates download metrics to VideoStat object, this is used for VideoFragment as it takes duration for calcuation purpose.
 */
void PrivateInstanceAAMP::UpdateVideoEndMetrics(MediaType mediaType, long bitrate, int curlOrHTTPCode, std::string& strUrl, double duration, double curlDownloadTime)
{
    UpdateVideoEndMetrics(mediaType, bitrate, curlOrHTTPCode, strUrl,duration,curlDownloadTime, false,false);
}
 
/**
 *   @brief updates time shift buffer status
 *
 */
void PrivateInstanceAAMP::UpdateVideoEndTsbStatus(bool btsbAvailable)
{
        pthread_mutex_lock(&mLock);
        if(mVideoEnd)
        {
                
                mVideoEnd->SetTsbStatus(btsbAvailable);
        }
        pthread_mutex_unlock(&mLock);
}   
 
/**
 * @brief updates profile capped status
 */
void PrivateInstanceAAMP::UpdateProfileCappedStatus(void)
{
        pthread_mutex_lock(&mLock);
        if(mVideoEnd)
        {
                mVideoEnd->SetProfileCappedStatus(mProfileCappedStatus);
        }
        pthread_mutex_unlock(&mLock);
}
 
/**
 * @brief updates download metrics to VideoStat object, this is used for VideoFragment as it takes duration for calcuation purpose.
 */
void PrivateInstanceAAMP::UpdateVideoEndMetrics(MediaType mediaType, long bitrate, int curlOrHTTPCode, std::string& strUrl, double duration, double curlDownloadTime, bool keyChanged, bool isEncrypted, ManifestData * manifestData)
{
        int audioIndex = 1;
        // ignore for write and aborted errors
        // these are generated after trick play options,
        if( curlOrHTTPCode > 0 &&  !(curlOrHTTPCode == CURLE_ABORTED_BY_CALLBACK || curlOrHTTPCode == CURLE_WRITE_ERROR) )
        {
                VideoStatDataType dataType = VideoStatDataType::VE_DATA_UNKNOWN;
                
                VideoStatTrackType trackType = VideoStatTrackType::STAT_UNKNOWN;
                VideoStatCountType eCountType = VideoStatCountType::COUNT_UNKNOWN;
                
                /*      COUNT_UNKNOWN,
                 COUNT_LIC_TOTAL,
                 COUNT_LIC_ENC_TO_CLR,
                 COUNT_LIC_CLR_TO_ENC,
                 COUNT_STALL,
                 */
                
                switch(mediaType)
                {
                        case eMEDIATYPE_MANIFEST:
                        {
                                dataType = VideoStatDataType::VE_DATA_MANIFEST;
                                trackType = VideoStatTrackType::STAT_MAIN;
                        }
                                break;
                                
                        case eMEDIATYPE_PLAYLIST_VIDEO:
                        {
                                dataType = VideoStatDataType::VE_DATA_MANIFEST;
                                trackType = VideoStatTrackType::STAT_VIDEO;
                        }
                                break;
                                
                        case eMEDIATYPE_PLAYLIST_AUDIO:
                        {
                                dataType = VideoStatDataType::VE_DATA_MANIFEST;
                                trackType = VideoStatTrackType::STAT_AUDIO;
                                audioIndex += mCurrentLanguageIndex;
                        }
                                break;
                                
                        case eMEDIATYPE_PLAYLIST_AUX_AUDIO:
                        {
                                dataType = VideoStatDataType::VE_DATA_MANIFEST;
                                trackType = VideoStatTrackType::STAT_AUDIO;
                                audioIndex += mCurrentLanguageIndex;
                        }
                                break;
                                
                        case eMEDIATYPE_PLAYLIST_IFRAME:
                        {
                                dataType = VideoStatDataType::VE_DATA_MANIFEST;
                                trackType = STAT_IFRAME;
                        }
                                break;
                                
                        case eMEDIATYPE_VIDEO:
                        {
                                dataType = VideoStatDataType::VE_DATA_FRAGMENT;
                                trackType = VideoStatTrackType::STAT_VIDEO;
                                // always Video fragment will be from same thread so mutex required
                                
                                // !!!!!!!!!! To Do : Support this stats for Audio Only streams !!!!!!!!!!!!!!!!!!!!!
                                //Is success
                                if (((curlOrHTTPCode == 200) || (curlOrHTTPCode == 206))  && duration > 0)
                                {
                                        if(mpStreamAbstractionAAMP->GetProfileCount())
                                        {
                                                long maxBitrateSupported = mpStreamAbstractionAAMP->GetMaxBitrate();
                                                if(maxBitrateSupported == bitrate)
                                                {
                                                        mTimeAtTopProfile += duration;
                                                        
                                                }
                                                
                                        }
                                        if(mTimeAtTopProfile == 0) // we havent achived top profile yet
                                        {
                                                mTimeToTopProfile += duration; // started at top profile
                                        }
                                        
                                        mPlaybackDuration += duration;
                                }
                                
                        }
                                break;
                        case eMEDIATYPE_AUDIO:
                        {
                                dataType = VideoStatDataType::VE_DATA_FRAGMENT;
                                trackType = VideoStatTrackType::STAT_AUDIO;
                                audioIndex += mCurrentLanguageIndex;
                        }
                                break;
                        case eMEDIATYPE_AUX_AUDIO:
                        {
                                dataType = VideoStatDataType::VE_DATA_FRAGMENT;
                                trackType = VideoStatTrackType::STAT_AUDIO;
                                audioIndex += mCurrentLanguageIndex;
                        }
                                break;
                        case eMEDIATYPE_IFRAME:
                        {
                                dataType = VideoStatDataType::VE_DATA_FRAGMENT;
                                trackType = VideoStatTrackType::STAT_IFRAME;
                        }
                                break;
                                
                        case eMEDIATYPE_INIT_IFRAME:
                        {
                                dataType = VideoStatDataType::VE_DATA_INIT_FRAGMENT;
                                trackType = VideoStatTrackType::STAT_IFRAME;
                        }
                                break;
                                
                        case eMEDIATYPE_INIT_VIDEO:
                        {
                                dataType = VideoStatDataType::VE_DATA_INIT_FRAGMENT;
                                trackType = VideoStatTrackType::STAT_VIDEO;
                        }
                                break;
                                
                        case eMEDIATYPE_INIT_AUDIO:
                        {
                                dataType = VideoStatDataType::VE_DATA_INIT_FRAGMENT;
                                trackType = VideoStatTrackType::STAT_AUDIO;
                                audioIndex += mCurrentLanguageIndex;
                        }
                                break;
                                
                        case eMEDIATYPE_INIT_AUX_AUDIO:
                        {
                                dataType = VideoStatDataType::VE_DATA_INIT_FRAGMENT;
                                trackType = VideoStatTrackType::STAT_AUDIO;
                                audioIndex += mCurrentLanguageIndex;
                        }
                                break;
                                
                        case eMEDIATYPE_SUBTITLE:
                        {
                                dataType = VideoStatDataType::VE_DATA_FRAGMENT;
                                trackType = VideoStatTrackType::STAT_SUBTITLE;
                        }
                                break;
                                
                        default:
                                break;
                }
                
                
                // Required for protecting mVideoStat object
                if( dataType != VideoStatDataType::VE_DATA_UNKNOWN
                   && trackType != VideoStatTrackType::STAT_UNKNOWN)
                {
                        pthread_mutex_lock(&mLock);
                        if(mVideoEnd)
                        {
                                //curl download time is in seconds, convert it into milliseconds for video end metrics
                                mVideoEnd->Increment_Data(dataType,trackType,bitrate,curlDownloadTime * 1000,curlOrHTTPCode,false,audioIndex, manifestData);
                                if((curlOrHTTPCode != 200) && (curlOrHTTPCode != 206) && strUrl.c_str())
                                {
                                        //set failure url
                                        mVideoEnd->SetFailedFragmentUrl(trackType,bitrate,strUrl);
                                }
                                if(dataType == VideoStatDataType::VE_DATA_FRAGMENT)
                                {
                                        mVideoEnd->Record_License_EncryptionStat(trackType,isEncrypted,keyChanged);
                                }
                        }
                        pthread_mutex_unlock(&mLock);
                        
                }
                else
                {
                        AAMPLOG_INFO("PrivateInstanceAAMP: Could Not update VideoEnd Event dataType:%d trackType:%d response:%d",
                                                 dataType,trackType,curlOrHTTPCode);
                }
        }
}
 
/**
 * @brief updates abr metrics to VideoStat object,
 */
void PrivateInstanceAAMP::UpdateVideoEndMetrics(AAMPAbrInfo & info)
{
        //only for Ramp down case
        if(info.desiredProfileIndex < info.currentProfileIndex)
        {
                AAMPLOG_INFO("UpdateVideoEnd:abrinfo currIdx:%d desiredIdx:%d for:%d",  info.currentProfileIndex,info.desiredProfileIndex,info.abrCalledFor);
                
                if(info.abrCalledFor == AAMPAbrType::AAMPAbrBandwidthUpdate)
                {
                        pthread_mutex_lock(&mLock);
                        if(mVideoEnd)
                        {
                                mVideoEnd->Increment_NetworkDropCount();
                        }
                        pthread_mutex_unlock(&mLock);
                }
                else if (info.abrCalledFor == AAMPAbrType::AAMPAbrFragmentDownloadFailed)
                {
                        pthread_mutex_lock(&mLock);
                        if(mVideoEnd)
                        {
                                mVideoEnd->Increment_ErrorDropCount();
                        }
                        pthread_mutex_unlock(&mLock);
                }
        }
}
 
/**
 * @brief updates download metrics to VideoStat object, this is used for VideoFragment as it takes duration for calcuation purpose.
 */
void PrivateInstanceAAMP::UpdateVideoEndMetrics(MediaType mediaType, long bitrate, int curlOrHTTPCode, std::string& strUrl, double curlDownloadTime, ManifestData * manifestData)
{
 
        UpdateVideoEndMetrics(mediaType, bitrate, curlOrHTTPCode, strUrl,0,curlDownloadTime, false, false, manifestData);
}
 
/**
 *   @brief Check if fragment caching is required
 */
bool PrivateInstanceAAMP::IsFragmentCachingRequired()
{
        //Prevent enabling Fragment Caching during Seek While Pause
        return (!mPauseOnFirstVideoFrameDisp && mFragmentCachingRequired);
}
 
/**
 * @brief Get player video size
 */
void PrivateInstanceAAMP::GetPlayerVideoSize(int &width, int &height)
{
        mStreamSink->GetVideoSize(width, height);
}
 
/**
 * @brief Set an idle callback as event dispatched state
 */
void PrivateInstanceAAMP::SetCallbackAsDispatched(guint id)
{
        pthread_mutex_lock(&mEventLock);
        std::map<guint, bool>::iterator  itr = mPendingAsyncEvents.find(id);
        if(itr != mPendingAsyncEvents.end())
        {
                assert (itr->second);
                mPendingAsyncEvents.erase(itr);
        }
        else
        {
                AAMPLOG_WARN("id %d not in mPendingAsyncEvents, insert and mark as not pending", id);
                mPendingAsyncEvents[id] = false;
        }
        pthread_mutex_unlock(&mEventLock);
}
 
/**
 *   @brief Set an idle callback as event pending state
 */
void PrivateInstanceAAMP::SetCallbackAsPending(guint id)
{
        pthread_mutex_lock(&mEventLock);
        std::map<guint, bool>::iterator  itr = mPendingAsyncEvents.find(id);
        if(itr != mPendingAsyncEvents.end())
        {
                assert (!itr->second);
                AAMPLOG_WARN("id %d already in mPendingAsyncEvents and completed, erase it", id);
                mPendingAsyncEvents.erase(itr);
        }
        else
        {
                mPendingAsyncEvents[id] = true;
        }
        pthread_mutex_unlock(&mEventLock);
}
 
/**
 * @brief Collect and send all key-value pairs for CMCD headers.
 */
void PrivateInstanceAAMP::CollectCMCDCustomHeaders(MediaType fileType,class CMCDHeaders *pCMCDMetrics)
{
        if(pCMCDMetrics!=NULL){
        MediaType simType = fileType;
        long temp=0;
        std::vector<long> bitrateList;
        pCMCDMetrics->SetSessionId(this->mTraceUUID);
        //For manifest sessionid and object type is passed as a part of CMCD Headers
        if(simType == eMEDIATYPE_MANIFEST)
        {
                pCMCDMetrics->SetMediaType("MANIFEST");
        }
        //For video sessionid,object type,currentvideobitrate,maximum videobitrate,bufferlength are send as a part of CMCD Headers
        if(simType == eMEDIATYPE_VIDEO)
        {
                pCMCDMetrics->SetMediaType("VIDEO");
                MediaTrack *video = mpStreamAbstractionAAMP->GetMediaTrack(eTRACK_VIDEO);
                if(video && video->enabled)
                {
                        if(video->GetBufferStatus() == BUFFER_STATUS_RED)//Bufferstarvation is send only when buffering turns red
                        {
                                pCMCDMetrics->SetBufferStarvation(true);
                        }
                        int videoBufferLength = ((int)video->GetBufferedDuration())*1000;
                        int videoBitrate  = ((int)mpStreamAbstractionAAMP->GetVideoBitrate())/1000;
                        bitrateList = mpStreamAbstractionAAMP->GetVideoBitrates();
                        for(int i = 0; i < bitrateList.size(); i++)
                        {
                                if(bitrateList[i]>temp)
                                {
                                        temp=bitrateList[i];
                                }
                        }
                        pCMCDMetrics->SetBitrate(videoBitrate);
                        pCMCDMetrics->SetTopBitrate(temp/1000);
                        pCMCDMetrics->SetNextUrl(mCMCDNextObjectRequest);
                        pCMCDMetrics->SetBufferLength(videoBufferLength);
                        AAMPLOG_INFO("video bufferlength %d video bitrate %d",videoBufferLength,videoBitrate);
                }
        }
        //For audio sessionid,object type,currentaudiobitrate,maximum audiobitrate,bufferlength are send as a part of CMCD Headers
        if(simType == eMEDIATYPE_AUDIO)
        {
                pCMCDMetrics->SetMediaType("AUDIO");
                MediaTrack *audio = mpStreamAbstractionAAMP->GetMediaTrack(eTRACK_AUDIO);
                if(audio && audio->enabled)
                {
                        if(audio->GetBufferStatus() == BUFFER_STATUS_RED)//Bufferstarvation is send only when buffering turns red
                        {
                                pCMCDMetrics->SetBufferStarvation(true);
                        }
                }
                bitrateList = mpStreamAbstractionAAMP->GetAudioBitrates();
                for(int i = 0; i < bitrateList.size(); i++)
                {
                        if(bitrateList[i]>temp)
                        {
                                temp=bitrateList[i];
                        }
                }
                int audioBufferLength = ((int)audio->GetBufferedDuration())*1000;
                pCMCDMetrics->SetBitrate(((int)mCMCDBandwidth)/1000);
                pCMCDMetrics->SetTopBitrate(temp/1000);
                pCMCDMetrics->SetNextUrl(mCMCDNextObjectRequest);
                pCMCDMetrics->SetBufferLength(audioBufferLength);
                AAMPLOG_INFO("audio bufferlength %daudio bitrate %d",audioBufferLength,((int)mCMCDBandwidth)/1000);
        }
        //For subtitle sessionid and object type are send as a part of CMCD Headers
        if(simType == eMEDIATYPE_SUBTITLE)
        {
                
                pCMCDMetrics->SetMediaType("SUBTITLE");
        }
        //For init fragment sessionid,object type,bitrate,maximum bitrate are send as a part of CMCD Headers
        if(simType == eMEDIATYPE_INIT_VIDEO)
        {
                pCMCDMetrics->SetMediaType("INIT_VIDEO");
                int initVideoBitrate  = ((int)mpStreamAbstractionAAMP->GetVideoBitrate())/1000;
                bitrateList = mpStreamAbstractionAAMP->GetVideoBitrates();
                for(int i = 0; i < bitrateList.size(); i++)
                {
                        if(bitrateList[i]>temp)
                        {
                                temp=bitrateList[i];
                        }
                }
                pCMCDMetrics->SetBitrate(initVideoBitrate);
                pCMCDMetrics->SetTopBitrate(temp);
 
        }
        if(simType == eMEDIATYPE_INIT_AUDIO)
        {
                pCMCDMetrics->SetMediaType("INIT_AUDIO");
                bitrateList = mpStreamAbstractionAAMP->GetAudioBitrates();
                for(int i = 0; i < bitrateList.size(); i++)
                {
                        if(bitrateList[i]>temp)
                        {
                                temp=bitrateList[i];
                        }
                }
                pCMCDMetrics->SetBitrate(((int)mCMCDBandwidth)/1000);
                pCMCDMetrics->SetTopBitrate(temp);
        }
        //For muxed streams sessionid,object type,bitrate,maximum bitrate,bufferlength are send as a part of CMCD Headers
        if(mpStreamAbstractionAAMP->IsMuxedStream())
        {
                pCMCDMetrics->SetMediaType("MUXED");
                bitrateList = mpStreamAbstractionAAMP->GetVideoBitrates();
                for(int i = 0; i < bitrateList.size(); i++)
                {
                        if(bitrateList[i]>temp)
                        {
                                temp=bitrateList[i];
                        }
                }
                int muxedBitrate  = ((int)mpStreamAbstractionAAMP->GetVideoBitrate())/1000;
                MediaTrack *video = mpStreamAbstractionAAMP->GetMediaTrack(eTRACK_VIDEO);
                if(video)
                {
                        if(video->GetBufferStatus() == BUFFER_STATUS_RED)///Bufferstarvation is send only when buffering turns red
                        {
                                pCMCDMetrics->SetBufferStarvation(true);
                        }
                }
                int muxedBufferLength = ((int)mpStreamAbstractionAAMP->GetBufferedDuration())*1000;             
                pCMCDMetrics->SetBitrate(muxedBitrate);
                pCMCDMetrics->SetTopBitrate(temp/1000);
                pCMCDMetrics->SetNextUrl(mCMCDNextObjectRequest);
                pCMCDMetrics->SetBufferLength(muxedBufferLength);
                AAMPLOG_INFO("muxed bufferlength %dmuxed bitrate %d",muxedBufferLength,muxedBitrate);
        }
        }
}
 
/**
 * @brief Add/Remove a custom HTTP header and value.
 */
void PrivateInstanceAAMP::AddCustomHTTPHeader(std::string headerName, std::vector<std::string> headerValue, bool isLicenseHeader)
{
        // Header name should be ending with :
        if(headerName.back() != ':')
        {
                headerName += ':';
        }
 
        if (isLicenseHeader)
        {
                if (headerValue.size() != 0)
                {
                        mCustomLicenseHeaders[headerName] = headerValue;
                }
                else
                {
                        mCustomLicenseHeaders.erase(headerName);
                }
        }
        else
        {
                if (headerValue.size() != 0)
                {
                        mCustomHeaders[headerName] = headerValue;
                }
                else
                {
                        mCustomHeaders.erase(headerName);
                }
        }
}
 
/**
 *  @brief UpdateLiveOffset live offset [Sec]
 */
void PrivateInstanceAAMP::UpdateLiveOffset()
{
        if(!IsLiveAdjustRequired()) /* Ideally checking the content is either "ivod/cdvr" to adjust the liveoffset on trickplay. */
        {
                GETCONFIGVALUE_PRIV(eAAMPConfig_CDVRLiveOffset,mLiveOffset);
        }
        else
        {
                GETCONFIGVALUE_PRIV(eAAMPConfig_LiveOffset,mLiveOffset);
        }
        AAMPLOG_INFO("Live offset value updated to %lf", mLiveOffset);
}
 
/**
 * @brief Send stalled event to listeners
 */
void PrivateInstanceAAMP::SendStalledErrorEvent()
{
        char description[MAX_ERROR_DESCRIPTION_LENGTH];
        memset(description, '\0', MAX_ERROR_DESCRIPTION_LENGTH);
        int stalltimeout;
        GETCONFIGVALUE_PRIV(eAAMPConfig_StallTimeoutMS,stalltimeout);
        snprintf(description, (MAX_ERROR_DESCRIPTION_LENGTH - 1), "Playback has been stalled for more than %d ms due to lack of new fragments", stalltimeout);
        SendErrorEvent(AAMP_TUNE_PLAYBACK_STALLED, description);
}
 
/**
 * @brief Sets up the timestamp sync for subtitle renderer
 */
void PrivateInstanceAAMP::UpdateSubtitleTimestamp()
{
        if (mpStreamAbstractionAAMP)
        {
                mpStreamAbstractionAAMP->StartSubtitleParser();
        }
}
 
/**
 * @brief pause/un-pause subtitles
 * 
 */
void PrivateInstanceAAMP::PauseSubtitleParser(bool pause)
{
        if (mpStreamAbstractionAAMP)
        {
                mpStreamAbstractionAAMP->PauseSubtitleParser(pause);
        }
}
 
/**
 * @brief Notify if first buffer processed by gstreamer
 */
void PrivateInstanceAAMP::NotifyFirstBufferProcessed()
{
        // If mFirstVideoFrameDisplayedEnabled, state will be changed in NotifyFirstVideoDisplayed()
        PrivAAMPState state;
        GetState(state);
        
        // In the middle of stop processing we can receive state changing callback (xione-7331)
        if (state == eSTATE_IDLE)
        {
                AAMPLOG_WARN( "skipped as in IDLE state" );
                return;
        }
        
        if (!mFirstVideoFrameDisplayedEnabled
                        && state == eSTATE_SEEKING)
        {
                SetState(eSTATE_PLAYING);
        }
        trickStartUTCMS = aamp_GetCurrentTimeMS();
        AAMPLOG_WARN("seek pos %.3f", seek_pos_seconds);
 
 
#ifdef USE_SECMANAGER
        if(ISCONFIGSET_PRIV(eAAMPConfig_UseSecManager))
        {
                //Thread to call setplayback speed as it needs a 500ms delay here
                std::thread t([&](){
                        mDRMSessionManager->setPlaybackSpeedState(rate,seek_pos_seconds, true);});
                t.detach();
                int x,y,w,h;
                sscanf(mStreamSink->GetVideoRectangle().c_str(),"%d,%d,%d,%d",&x,&y,&w,&h);
        AAMPLOG_WARN("calling setVideoWindowSize  w:%d x h:%d ",w,h);
        mDRMSessionManager->setVideoWindowSize(w,h);
        }
#endif
        
}
 
/**
 * @brief Reset trick start position
 */
void PrivateInstanceAAMP::ResetTrickStartUTCTime()
{
        trickStartUTCMS = aamp_GetCurrentTimeMS();
}
 
/**
 * @brief Get stream type
 */
int PrivateInstanceAAMP::getStreamType()
{
 
        int type = 0;
 
        if(mMediaFormat == eMEDIAFORMAT_DASH)
        {
                type = 20;
        }
        else if( mMediaFormat == eMEDIAFORMAT_HLS)
        {
                type = 10;
        }
        else if (mMediaFormat == eMEDIAFORMAT_PROGRESSIVE)// eMEDIAFORMAT_PROGRESSIVE
        {
                type = 30;
        }
        else if (mMediaFormat == eMEDIAFORMAT_HLS_MP4)
        {
                type = 40;
        }
        else
        {
                type = 0;
        }
 
        if (mCurrentDrm != nullptr) {
                type += mCurrentDrm->getDrmCodecType();
        }
        return type;
}
 
/**
 * @brief Get Mediaformat type
 *
 * @returns eMEDIAFORMAT
 */
MediaFormat PrivateInstanceAAMP::GetMediaFormatTypeEnum() const
{
        return mMediaFormat;
}
 
#if defined(USE_SECCLIENT) || defined(USE_SECMANAGER)
 
/**
 * @brief Extracts / Generates MoneyTrace string
 */
void PrivateInstanceAAMP::GetMoneyTraceString(std::string &customHeader) const
{
        char moneytracebuf[512];
        memset(moneytracebuf, 0, sizeof(moneytracebuf));
 
        if (mCustomHeaders.size() > 0)
        {
                for (std::unordered_map<std::string, std::vector<std::string>>::const_iterator it = mCustomHeaders.begin();
                        it != mCustomHeaders.end(); it++)
                {
                        if (it->first.compare("X-MoneyTrace:") == 0)
                        {
                                if (it->second.size() >= 2)
                                {
                                        snprintf(moneytracebuf, sizeof(moneytracebuf), "trace-id=%s;parent-id=%s;span-id=%lld",
                                        (const char*)it->second.at(0).c_str(),
                                        (const char*)it->second.at(1).c_str(),
                                        aamp_GetCurrentTimeMS());
                                }
                                else if (it->second.size() == 1)
                                {
                                        snprintf(moneytracebuf, sizeof(moneytracebuf), "trace-id=%s;parent-id=%lld;span-id=%lld",
                                                (const char*)it->second.at(0).c_str(),
                                                aamp_GetCurrentTimeMS(),
                                                aamp_GetCurrentTimeMS());
                                }
                                customHeader.append(moneytracebuf);
                                break;
                        }
                }
        }
        // No money trace is available in customheader from JS , create a new moneytrace locally
        if(customHeader.size() == 0)
        {
                // No Moneytrace info available in tune data 
                AAMPLOG_WARN("No Moneytrace info available in tune request,need to generate one");
                uuid_t uuid;
                uuid_generate(uuid);
                char uuidstr[128];
                uuid_unparse(uuid, uuidstr);
                for (char *ptr = uuidstr; *ptr; ++ptr) {
                        *ptr = tolower(*ptr);
                }
                snprintf(moneytracebuf,sizeof(moneytracebuf),"trace-id=%s;parent-id=%lld;span-id=%lld",uuidstr,aamp_GetCurrentTimeMS(),aamp_GetCurrentTimeMS());
                customHeader.append(moneytracebuf);
        }       
        AAMPLOG_TRACE("[GetMoneyTraceString] MoneyTrace[%s]",customHeader.c_str());
}
#endif /* USE_SECCLIENT || USE_SECMANAGER */
 
/**
 * @brief Notify the decryption completion of the fist fragment.
 */
void PrivateInstanceAAMP::NotifyFirstFragmentDecrypted()
{
        if(mTunedEventPending)
        {
                if (eTUNED_EVENT_ON_FIRST_FRAGMENT_DECRYPTED == GetTuneEventConfig(IsLive()))
                {
                        // For HLS - This is invoked by fetcher thread, so we have to sent asynchronously
                        if (SendTunedEvent(false))
                        {
                                AAMPLOG_WARN("aamp: %s - sent tune event after first fragment fetch and decrypt", mMediaFormatName[mMediaFormat]);
                        }
                }
        }
}
 
/**
 * @brief  Get PTS of first sample.
 */
double PrivateInstanceAAMP::GetFirstPTS()
{
        assert(NULL != mpStreamAbstractionAAMP);
        return mpStreamAbstractionAAMP->GetFirstPTS();
}
 
/**
 * @brief Check if Live Adjust is required for current content. ( For "vod/ivod/ip-dvr/cdvr/eas", Live Adjust is not required ).
 */
bool PrivateInstanceAAMP::IsLiveAdjustRequired()
{
        bool retValue;
 
        switch (mContentType)
        {
                case ContentType_IVOD:
                case ContentType_VOD:
                case ContentType_CDVR:
                case ContentType_IPDVR:
                case ContentType_EAS:
                        retValue = false;
                        break;
 
                case ContentType_SLE:
                        retValue = true;
                        break;
 
                default:
                        retValue = true;
                        break;
        }
        return retValue;
}
 
/**
 * @brief Generate http header response event
 */
void PrivateInstanceAAMP::SendHTTPHeaderResponse()
{
        for (auto const& pair: httpHeaderResponses) {
                HTTPResponseHeaderEventPtr event = std::make_shared<HTTPResponseHeaderEvent>(pair.first.c_str(), pair.second);
                AAMPLOG_INFO("HTTPResponseHeader evt Header:%s Response:%s", event->getHeader().c_str(), event->getResponse().c_str());
                SendEvent(event,AAMP_EVENT_ASYNC_MODE);
        }
}
 
/**
 * @brief  Generate media metadata event based on parsed attribute values.
 *
 */
void PrivateInstanceAAMP::SendMediaMetadataEvent(void)
{
        std::vector<long> bitrateList;
        std::set<std::string> langList;
        std::vector<float> supportedPlaybackSpeeds { -64, -32, -16, -4, -1, 0, 0.5, 1, 4, 16, 32, 64 };
        int langCount = 0;
        int bitrateCount = 0;
        int supportedSpeedCount = 0;
        int width  = 1280;
        int height = 720;
 
        bitrateList = mpStreamAbstractionAAMP->GetVideoBitrates();
        for (int i = 0; i <mMaxLanguageCount; i++)
        {
                langList.insert(mLanguageList[i]);
        }
 
        GetPlayerVideoSize(width, height);
 
        std::string drmType = "NONE";
        std::shared_ptr<AampDrmHelper> helper = GetCurrentDRM();
        if (helper)
        {
                drmType = helper->friendlyName();
        }
 
        MediaMetadataEventPtr event = std::make_shared<MediaMetadataEvent>(CONVERT_SEC_TO_MS(durationSeconds), width, height, mpStreamAbstractionAAMP->hasDrm, IsLive(), drmType, mpStreamAbstractionAAMP->mProgramStartTime);
 
        for (auto iter = langList.begin(); iter != langList.end(); iter++)
        {
                if (!iter->empty())
                {
                        // assert if size >= < MAX_LANGUAGE_TAG_LENGTH 
                        assert(iter->size() < MAX_LANGUAGE_TAG_LENGTH);
                        event->addLanguage((*iter));
                }
        }
 
        for (int i = 0; i < bitrateList.size(); i++)
        {
                event->addBitrate(bitrateList[i]);
        }
 
        //Iframe track present and hence playbackRate change is supported
        if (mIsIframeTrackPresent)
        {
                if(!(ISCONFIGSET_PRIV(eAAMPConfig_EnableSlowMotion)))
                {
                        auto position = std::find(supportedPlaybackSpeeds.begin(), supportedPlaybackSpeeds.end(), 0.5);
                        if(position != supportedPlaybackSpeeds.end())
                        {
                                supportedPlaybackSpeeds.erase(position); //remove 0.5 from supported speeds
                        }
                }
 
                for(int i = 0; i < supportedPlaybackSpeeds.size(); i++)
                {
                        event->addSupportedSpeed(supportedPlaybackSpeeds[i]);
                }
        }
        else
        {
                //Supports only pause and play
                event->addSupportedSpeed(0);
                if(ISCONFIGSET_PRIV(eAAMPConfig_EnableSlowMotion))
                {
                        event->addSupportedSpeed(0.5);
                }
                event->addSupportedSpeed(1);
        }
 
        event->setMediaFormat(mMediaFormatName[mMediaFormat]);
 
        SendEvent(event,AAMP_EVENT_ASYNC_MODE);
}
 
/**
 * @brief  Generate supported speeds changed event based on arg passed.
 */
void PrivateInstanceAAMP::SendSupportedSpeedsChangedEvent(bool isIframeTrackPresent)
{
        SupportedSpeedsChangedEventPtr event = std::make_shared<SupportedSpeedsChangedEvent>();
        std::vector<float> supportedPlaybackSpeeds { -64, -32, -16, -4, -1, 0, 0.5, 1, 4, 16, 32, 64 };
        int supportedSpeedCount = 0;
 
        //Iframe track present and hence playbackRate change is supported
        if (isIframeTrackPresent)
        {
                if(!(ISCONFIGSET_PRIV(eAAMPConfig_EnableSlowMotion)))
                {
                        auto position = std::find(supportedPlaybackSpeeds.begin(), supportedPlaybackSpeeds.end(), 0.5);
                        if(position != supportedPlaybackSpeeds.end())
                        {
                                supportedPlaybackSpeeds.erase(position); //remove 0.5 from supported speeds
                        }
                }
 
                for(int i = 0; i < supportedPlaybackSpeeds.size(); i++)
                {
                        event->addSupportedSpeed(supportedPlaybackSpeeds[i]);;
                }
        }
        else
        {
                //Supports only pause and play
                event->addSupportedSpeed(0);
                if(ISCONFIGSET_PRIV(eAAMPConfig_EnableSlowMotion))
                {
                        event->addSupportedSpeed(0.5);
                }
                event->addSupportedSpeed(1);
        }
 
        AAMPLOG_WARN("aamp: sending supported speeds changed event with count %d", event->getSupportedSpeedCount());
        SendEvent(event,AAMP_EVENT_ASYNC_MODE);
}
 
/**
 * @brief Generate Blocked event based on args passed.
 */
void PrivateInstanceAAMP::SendBlockedEvent(const std::string & reason)
{
        BlockedEventPtr event = std::make_shared<BlockedEvent>(reason);
        SendEvent(event,AAMP_EVENT_ASYNC_MODE);
#ifdef AAMP_CC_ENABLED
        if (0 == reason.compare("SERVICE_PIN_LOCKED"))
        {
                if (ISCONFIGSET_PRIV(eAAMPConfig_NativeCCRendering))
                {
                        AampCCManager::GetInstance()->SetParentalControlStatus(true);
                }
        }
#endif
}
 
/**
 * @brief  Generate WatermarkSessionUpdate event based on args passed.
 */
void PrivateInstanceAAMP::SendWatermarkSessionUpdateEvent(uint32_t sessionHandle, uint32_t status, const std::string &system)
{
        WatermarkSessionUpdateEventPtr event = std::make_shared<WatermarkSessionUpdateEvent>(sessionHandle, status, system);
        SendEvent(event,AAMP_EVENT_ASYNC_MODE);
}
 
/**
 * @brief  Check if tune completed or not.
 */
bool PrivateInstanceAAMP::IsTuneCompleted()
{
        return mTuneCompleted;
}
 
/**
 * @brief Get Preferred DRM.
 */
DRMSystems PrivateInstanceAAMP::GetPreferredDRM()
{
        int drmType;
        GETCONFIGVALUE_PRIV(eAAMPConfig_PreferredDRM,drmType);
        return (DRMSystems)drmType;
}
 
/**
 * @brief Notification from the stream abstraction that a new SCTE35 event is found.
 */
void PrivateInstanceAAMP::FoundEventBreak(const std::string &adBreakId, uint64_t startMS, EventBreakInfo brInfo)
{
        if(ISCONFIGSET_PRIV(eAAMPConfig_EnableClientDai) && !adBreakId.empty())
        {
                AAMPLOG_WARN("[CDAI] Found Adbreak on period[%s] Duration[%d]", adBreakId.c_str(), brInfo.duration);
                std::string adId("");
                std::string url("");
                mCdaiObject->SetAlternateContents(adBreakId, adId, url, startMS, brInfo.duration);      //A placeholder to avoid multiple scte35 event firing for the same adbreak
                SaveNewTimedMetadata((long long) startMS, brInfo.name.c_str(), brInfo.payload.c_str(), brInfo.payload.size(), adBreakId.c_str(), brInfo.duration);
        }
}
 
/**
 *  @brief Setting the alternate contents' (Ads/blackouts) URL
 */
void PrivateInstanceAAMP::SetAlternateContents(const std::string &adBreakId, const std::string &adId, const std::string &url)
{
        if(ISCONFIGSET_PRIV(eAAMPConfig_EnableClientDai))
        {
                mCdaiObject->SetAlternateContents(adBreakId, adId, url);
        }
        else
        {
                AAMPLOG_WARN("is called! CDAI not enabled!! Rejecting the promise.");
                SendAdResolvedEvent(adId, false, 0, 0);
        }
}
 
/**
 * @brief Send status of Ad manifest downloading & parsing
 */
void PrivateInstanceAAMP::SendAdResolvedEvent(const std::string &adId, bool status, uint64_t startMS, uint64_t durationMs)
{
        if (mDownloadsEnabled)  //Send it, only if Stop not called
        {
                AdResolvedEventPtr e = std::make_shared<AdResolvedEvent>(status, adId, startMS, durationMs);
                AAMPLOG_WARN("PrivateInstanceAAMP: [CDAI] Sent resolved status=%d for adId[%s]", status, adId.c_str());
                SendEvent(e,AAMP_EVENT_ASYNC_MODE);
        }
}
 
/**
 * @brief Deliver all pending Ad events to JSPP
 */
void PrivateInstanceAAMP::DeliverAdEvents(bool immediate)
{
        std::lock_guard<std::mutex> lock(mAdEventQMtx);
        while (!mAdEventsQ.empty())
        {
                AAMPEventPtr e = mAdEventsQ.front();
                if(immediate)
                {
                        mEventManager->SendEvent(e,AAMP_EVENT_SYNC_MODE);
                }
                else
                {
                        mEventManager->SendEvent(e,AAMP_EVENT_ASYNC_MODE);
                }
                AAMPEventType evtType = e->getType();
                AAMPLOG_WARN("PrivateInstanceAAMP:, [CDAI] Delivered AdEvent[%s] to JSPP.", ADEVENT2STRING(evtType));
                if(AAMP_EVENT_AD_PLACEMENT_START == evtType)
                {
                        AdPlacementEventPtr placementEvt = std::dynamic_pointer_cast<AdPlacementEvent>(e);
                        mAdProgressId       = placementEvt->getAdId();
                        mAdPrevProgressTime = NOW_STEADY_TS_MS;
                        mAdCurOffset        = placementEvt->getOffset();
                        mAdDuration         = placementEvt->getDuration();
                }
                else if(AAMP_EVENT_AD_PLACEMENT_END == evtType || AAMP_EVENT_AD_PLACEMENT_ERROR == evtType)
                {
                        mAdProgressId = "";
                }
                mAdEventsQ.pop();
        }
}
 
/**
 * @brief Send Ad reservation event
 */
void PrivateInstanceAAMP::SendAdReservationEvent(AAMPEventType type, const std::string &adBreakId, uint64_t position, bool immediate)
{
        if(AAMP_EVENT_AD_RESERVATION_START == type || AAMP_EVENT_AD_RESERVATION_END == type)
        {
                AAMPLOG_INFO("PrivateInstanceAAMP: [CDAI] Pushed [%s] of adBreakId[%s] to Queue.", ADEVENT2STRING(type), adBreakId.c_str());
 
                AdReservationEventPtr e = std::make_shared<AdReservationEvent>(type, adBreakId, position);
 
                {
                        {
                                std::lock_guard<std::mutex> lock(mAdEventQMtx);
                                mAdEventsQ.push(e);
                        }
                        if(immediate)
                        {
                                //Despatch all ad events now
                                DeliverAdEvents(true);
                        }
                }
        }
}
 
/**
 * @brief Send Ad placement event
 */
void PrivateInstanceAAMP::SendAdPlacementEvent(AAMPEventType type, const std::string &adId, uint32_t position, uint32_t adOffset, uint32_t adDuration, bool immediate, long error_code)
{
        if(AAMP_EVENT_AD_PLACEMENT_START <= type && AAMP_EVENT_AD_PLACEMENT_ERROR >= type)
        {
                AAMPLOG_INFO("PrivateInstanceAAMP: [CDAI] Pushed [%s] of adId[%s] to Queue.", ADEVENT2STRING(type), adId.c_str());
 
                AdPlacementEventPtr e = std::make_shared<AdPlacementEvent>(type, adId, position, adOffset * 1000 /*MS*/, adDuration, error_code);
 
                {
                        {
                                std::lock_guard<std::mutex> lock(mAdEventQMtx);
                                mAdEventsQ.push(e);
                        }
                        if(immediate)
                        {
                                //Despatch all ad events now
                                DeliverAdEvents(true);
                        }
                }
        }
}
 
/**
 *  @brief Get stream type as printable format
 */
std::string PrivateInstanceAAMP::getStreamTypeString()
{
        std::string type = mMediaFormatName[mMediaFormat];
 
        if(mCurrentDrm != nullptr) //Incomplete Init won't be set the DRM
        {
                type += "/";
                type += mCurrentDrm->friendlyName();
        }
        else
        {
                type += "/Clear";
        }
        return type;
}
 
/**
 * @brief Convert media file type to profiler bucket type
 */
ProfilerBucketType PrivateInstanceAAMP::mediaType2Bucket(MediaType fileType)
{
        ProfilerBucketType pbt;
        switch(fileType)
        {
                case eMEDIATYPE_VIDEO:
                        pbt = PROFILE_BUCKET_FRAGMENT_VIDEO;
                        break;
                case eMEDIATYPE_AUDIO:
                        pbt = PROFILE_BUCKET_FRAGMENT_AUDIO;
                        break;
                case eMEDIATYPE_SUBTITLE:
                        pbt = PROFILE_BUCKET_FRAGMENT_SUBTITLE;
                        break;
                case eMEDIATYPE_AUX_AUDIO:
                        pbt = PROFILE_BUCKET_FRAGMENT_AUXILIARY;
                        break;
                case eMEDIATYPE_MANIFEST:
                        pbt = PROFILE_BUCKET_MANIFEST;
                        break;
                case eMEDIATYPE_INIT_VIDEO:
                        pbt = PROFILE_BUCKET_INIT_VIDEO;
                        break;
                case eMEDIATYPE_INIT_AUDIO:
                        pbt = PROFILE_BUCKET_INIT_AUDIO;
                        break;
                case eMEDIATYPE_INIT_SUBTITLE:
                        pbt = PROFILE_BUCKET_INIT_SUBTITLE;
                        break;
                case eMEDIATYPE_INIT_AUX_AUDIO:
                        pbt = PROFILE_BUCKET_INIT_AUXILIARY;
                        break;
                case eMEDIATYPE_PLAYLIST_VIDEO:
                        pbt = PROFILE_BUCKET_PLAYLIST_VIDEO;
                        break;
                case eMEDIATYPE_PLAYLIST_AUDIO:
                        pbt = PROFILE_BUCKET_PLAYLIST_AUDIO;
                        break;
                case eMEDIATYPE_PLAYLIST_SUBTITLE:
                        pbt = PROFILE_BUCKET_PLAYLIST_SUBTITLE;
                        break;
                case eMEDIATYPE_PLAYLIST_AUX_AUDIO:
                        pbt = PROFILE_BUCKET_PLAYLIST_AUXILIARY;
                        break;
                default:
                        pbt = (ProfilerBucketType)fileType;
                        break;
        }
        return pbt;
}
 
/**
 * @brief Sets Recorded URL from Manifest received form XRE
 */
void PrivateInstanceAAMP::SetTunedManifestUrl(bool isrecordedUrl)
{
        mTunedManifestUrl.assign(mManifestUrl);
        AAMPLOG_TRACE("mManifestUrl: %s",mManifestUrl.c_str());
        if(isrecordedUrl)
        {
                DeFog(mTunedManifestUrl);
                mTunedManifestUrl.replace(0,4,"_fog");
        }
        AAMPLOG_TRACE("PrivateInstanceAAMP::tunedManifestUrl:%s ", mTunedManifestUrl.c_str());
}
 
/**
 * @brief Gets Recorded URL from Manifest received form XRE.
 */
const char* PrivateInstanceAAMP::GetTunedManifestUrl()
{
        AAMPLOG_TRACE("PrivateInstanceAAMP::tunedManifestUrl:%s ", mTunedManifestUrl.c_str());
        return mTunedManifestUrl.c_str();
}
 
/**
 *  @brief To get the network proxy
 */
std::string PrivateInstanceAAMP::GetNetworkProxy()
{
        std::string proxy;
        GETCONFIGVALUE_PRIV(eAAMPConfig_NetworkProxy,proxy);
        return proxy;
}
 
/**
 * @brief To get the proxy for license request
 */
std::string PrivateInstanceAAMP::GetLicenseReqProxy()
{
        std::string proxy;
        GETCONFIGVALUE_PRIV(eAAMPConfig_LicenseProxy,proxy);
        return proxy;
}
 
 
/**
 * @brief Signal trick mode discontinuity to stream sink
 */
void PrivateInstanceAAMP::SignalTrickModeDiscontinuity()
{
        if (mStreamSink)
        {
                mStreamSink->SignalTrickModeDiscontinuity();
        }
}
 
/**
 *   @brief Check if current stream is muxed
 */
bool PrivateInstanceAAMP::IsMuxedStream()
{
        bool ret = false;
        if (mpStreamAbstractionAAMP)
        {
                ret = mpStreamAbstractionAAMP->IsMuxedStream();
        }
        return ret;
}
 
/**
 * @brief Stop injection for a track.
 * Called from StopInjection
 */
void PrivateInstanceAAMP::StopTrackInjection(MediaType type)
{
#ifdef AAMP_DEBUG_FETCH_INJECT
        if ((1 << type) & AAMP_DEBUG_FETCH_INJECT)
        {
                AAMPLOG_WARN ("PrivateInstanceAAMP: Enter. type = %d", (int) type);
        }
#endif
        if (!mTrackInjectionBlocked[type])
        {
                AAMPLOG_TRACE("PrivateInstanceAAMP: for type %s", (type == eMEDIATYPE_AUDIO) ? "audio" : "video");
                pthread_mutex_lock(&mLock);
                mTrackInjectionBlocked[type] = true;
                pthread_mutex_unlock(&mLock);
        }
        AAMPLOG_TRACE ("PrivateInstanceAAMP::Exit. type = %d", (int) type);
}
 
/**
 * @brief Resume injection for a track.
 * Called from StartInjection
 */
void PrivateInstanceAAMP::ResumeTrackInjection(MediaType type)
{
#ifdef AAMP_DEBUG_FETCH_INJECT
        if ((1 << type) & AAMP_DEBUG_FETCH_INJECT)
        {
                AAMPLOG_WARN ("PrivateInstanceAAMP: Enter. type = %d", (int) type);
        }
#endif
        if (mTrackInjectionBlocked[type])
        {
                AAMPLOG_TRACE("PrivateInstanceAAMP: for type %s", (type == eMEDIATYPE_AUDIO) ? "audio" : "video");
                pthread_mutex_lock(&mLock);
                mTrackInjectionBlocked[type] = false;
                pthread_mutex_unlock(&mLock);
        }
        AAMPLOG_TRACE ("PrivateInstanceAAMP::Exit. type = %d", (int) type);
}
 
/**
 * @brief Receives first video PTS of the current playback
 */
void PrivateInstanceAAMP::NotifyFirstVideoPTS(unsigned long long pts, unsigned long timeScale)
{
        if (mpStreamAbstractionAAMP)
        {
                mpStreamAbstractionAAMP->NotifyFirstVideoPTS(pts, timeScale);
        }
}
 
/**
 * @brief Notifies base PTS of the HLS video playback
 */
void PrivateInstanceAAMP::NotifyVideoBasePTS(unsigned long long basepts, unsigned long timeScale)
{
        mVideoBasePTS = basepts;
        AAMPLOG_INFO("mVideoBasePTS::%llus", mVideoBasePTS);
}
 
/**
 * @brief To send webvtt cue as an event
 */
void PrivateInstanceAAMP::SendVTTCueDataAsEvent(VTTCue* cue)
{
        //This function is called from an idle handler and hence we call SendEventSync
        if (mEventManager->IsEventListenerAvailable(AAMP_EVENT_WEBVTT_CUE_DATA))
        {
                WebVttCueEventPtr ev = std::make_shared<WebVttCueEvent>(cue);
                mEventManager->SendEvent(ev,AAMP_EVENT_SYNC_MODE);
        }
}
 
/**
 * @brief To check if subtitles are enabled
 */
bool PrivateInstanceAAMP::IsSubtitleEnabled(void)
{
        // Assumption being that enableSubtec and event listener will not be registered at the same time
        // in which case subtec gets priority over event listener
        return (ISCONFIGSET_PRIV(eAAMPConfig_Subtec_subtitle)  ||       WebVTTCueListenersRegistered());
}
 
/**
 * @brief To check if JavaScript cue listeners are registered
 */
bool PrivateInstanceAAMP::WebVTTCueListenersRegistered(void)
{
        return mEventManager->IsSpecificEventListenerAvailable(AAMP_EVENT_WEBVTT_CUE_DATA);
}
 
/**
 * @brief To get any custom license HTTP headers that was set by application
 */
void PrivateInstanceAAMP::GetCustomLicenseHeaders(std::unordered_map<std::string, std::vector<std::string>>& customHeaders)
{
        customHeaders.insert(mCustomLicenseHeaders.begin(), mCustomLicenseHeaders.end());
}
 
/**
 * @brief Sends an ID3 metadata event.
 */
void PrivateInstanceAAMP::SendId3MetadataEvent(Id3CallbackData* id3Metadata)
{
        if(id3Metadata) {
        ID3MetadataEventPtr e = std::make_shared<ID3MetadataEvent>(id3Metadata->data, id3Metadata->schemeIdUri, id3Metadata->value, id3Metadata->timeScale, id3Metadata->presentationTime, id3Metadata->eventDuration, id3Metadata->id, id3Metadata->timestampOffset);
        if (ISCONFIGSET_PRIV(eAAMPConfig_ID3Logging))
        {
                std::vector<uint8_t> metadata = e->getMetadata();
                int metadataLen = e->getMetadataSize();
                int printableLen = 0;
                std::ostringstream tag;
 
                tag << "ID3 tag length: " << metadataLen;
        
                if (metadataLen > 0 )
                {
                        tag << " payload: ";
 
                        for (int i = 0; i < metadataLen; i++)
                        {
                                if (std::isprint(metadata[i]))
                                {
                                        tag << metadata[i];
                                        printableLen++;
                                }
                        }
                }
                // Logger has a maximum message size limit, warn if too big
                // Current large ID3 tag size is 1055, but printable < MAX_DEBUG_LOG_BUFF_SIZE.
                std::string tagLog(tag.str());
                AAMPLOG_INFO("%s", tag.str().c_str());
                AAMPLOG_INFO("{schemeIdUri:\"%s\",value:\"%s\",presentationTime:%" PRIu64 ",timeScale:%" PRIu32 ",eventDuration:%" PRIu32 ",id:%" PRIu32 ",timestampOffset:%" PRIu64 "}",e->getSchemeIdUri().c_str(), e->getValue().c_str(), e->getPresentationTime(), e->getTimeScale(), e->getEventDuration(), e->getId(), e->getTimestampOffset());
 
                if (printableLen > MAX_DEBUG_LOG_BUFF_SIZE)
                {
                        AAMPLOG_WARN("ID3 log was truncated, original size %d (printable %d)" , metadataLen, printableLen);
                }
        }
        mEventManager->SendEvent(e,AAMP_EVENT_ASYNC_MODE);
        }
}
 
/**
 * @brief Sending a flushing seek to stream sink with given position
 */
void PrivateInstanceAAMP::FlushStreamSink(double position, double rate)
{
#ifndef AAMP_STOP_SINK_ON_SEEK
        if (mStreamSink)
        {
                if(ISCONFIGSET_PRIV(eAAMPConfig_MidFragmentSeek) && position != 0 )
                {
                        //RDK-26957 Adding midSeekPtsOffset to position value.
                        //Enables us to seek to the desired position in the mp4 fragment.
                        mStreamSink->SeekStreamSink(position + GetFirstPTS(), rate);
                }
                else
                {
                        mStreamSink->SeekStreamSink(position, rate);
                }
        }
#endif
}
 
/**
 * @brief PreCachePlaylistDownloadTask Thread function for PreCaching Playlist 
 */
void PrivateInstanceAAMP::PreCachePlaylistDownloadTask()
{
        // This is the thread function to download all the HLS Playlist in a 
        // differed manner
        int maxWindowforDownload = mPreCacheDnldTimeWindow * 60; // convert to seconds  
        int szPlaylistCount = mPreCacheDnldList.size();
        if(szPlaylistCount)
        {
                PrivAAMPState state;
                // First wait for Tune to complete to start this functionality
                pthread_mutex_lock(&mMutexPlaystart);
                pthread_cond_wait(&waitforplaystart, &mMutexPlaystart);
                pthread_mutex_unlock(&mMutexPlaystart);
                // May be Stop is called to release all resources .
                // Before download , check the state 
                GetState(state);
                // Check for state not IDLE also to avoid DELIA-46092
                if(state != eSTATE_RELEASED && state != eSTATE_IDLE && state != eSTATE_ERROR)
                {
                        CurlInit(eCURLINSTANCE_PLAYLISTPRECACHE, 1, GetNetworkProxy());
                        SetCurlTimeout(mPlaylistTimeoutMs, eCURLINSTANCE_PLAYLISTPRECACHE);
                        int sleepTimeBetweenDnld = (maxWindowforDownload / szPlaylistCount) * 1000; // time in milliSec 
                        int idx = 0;
                        do
                        {
                                if(DownloadsAreEnabled())
                                {
                                        InterruptableMsSleep(sleepTimeBetweenDnld);
 
                                        // First check if the file is already in Cache
                                        PreCacheUrlStruct newelem = mPreCacheDnldList.at(idx);
                                        
                                        // check if url cached ,if not download
                                        if(getAampCacheHandler()->IsUrlCached(newelem.url)==false)
                                        {
                                                AAMPLOG_WARN("Downloading Playlist Type:%d for PreCaching:%s",
                                                        newelem.type, newelem.url.c_str());
                                                std::string playlistUrl;
                                                std::string playlistEffectiveUrl;
                                                GrowableBuffer playlistStore ;
                                                long http_error;
                                                double downloadTime;
                                                if(GetFile(newelem.url, &playlistStore, playlistEffectiveUrl, &http_error, &downloadTime, NULL, eCURLINSTANCE_PLAYLISTPRECACHE, true, newelem.type))
                                                {
                                                        // If successful download , then insert into Cache 
                                                        getAampCacheHandler()->InsertToPlaylistCache(newelem.url, &playlistStore, playlistEffectiveUrl, false, newelem.type);
                                                        aamp_Free(&playlistStore);
                                                }       
                                        }
                                        idx++;
                                }
                                else
                                {
                                        // this can come here if trickplay is done or play started late
                                        if(state == eSTATE_SEEKING || state == eSTATE_PREPARED)
                                        {
                                                // wait for seek to complete 
                                                sleep(1);
                                        }
                                        else
                                        {
                                                usleep(500000); // call sleep for other stats except seeking and prepared, otherwise this thread will run in highest priority until the state changes.
                                        }
                                }
                                GetState(state);
                        }while (idx < mPreCacheDnldList.size() && state != eSTATE_RELEASED && state != eSTATE_IDLE && state != eSTATE_ERROR);
                        mPreCacheDnldList.clear();
                        CurlTerm(eCURLINSTANCE_PLAYLISTPRECACHE);
                }
        }
        AAMPLOG_WARN("End of PreCachePlaylistDownloadTask ");
}
 
/**
 * @brief SetPreCacheDownloadList - Function to assign the PreCaching file list
 */
void PrivateInstanceAAMP::SetPreCacheDownloadList(PreCacheUrlList &dnldListInput)
{
        mPreCacheDnldList = dnldListInput;
        if(mPreCacheDnldList.size())
        {
                AAMPLOG_WARN("Got Playlist PreCache list of Size : %lu", mPreCacheDnldList.size());
        }
        
}
 
/**
 *   @brief get the current text preference set by user
 *
 *   @return json string with preference data
 */
std::string PrivateInstanceAAMP::GetPreferredTextProperties()
{
        //Convert to JSON format
        std::string preferrence;
        cJSON *item;
        item = cJSON_CreateObject();
        if(!preferredTextLanguagesString.empty())
        {
                cJSON_AddStringToObject(item, "preferred-text-languages", preferredTextLanguagesString.c_str());
        }
        if(!preferredTextLabelString.empty())
        {
                cJSON_AddStringToObject(item, "preferred-text-labels", preferredTextLabelString.c_str());
        }
        if(!preferredTextRenditionString.empty())
        {
                cJSON_AddStringToObject(item, "preferred-text-rendition", preferredTextRenditionString.c_str());
        }
        if(!preferredTextTypeString.empty())
        {
                cJSON_AddStringToObject(item, "preferred-text-type", preferredTextTypeString.c_str());
        }
        if(!preferredTextAccessibilityNode.getSchemeId().empty())
        {
                cJSON *accessibility = cJSON_AddObjectToObject(item, "preferred-text-accessibility");
                cJSON_AddStringToObject(accessibility, "schemeId", preferredTextAccessibilityNode.getSchemeId().c_str());
                if (preferredTextAccessibilityNode.getTypeName() == "int_value")
                {
                        cJSON_AddNumberToObject(accessibility, preferredTextAccessibilityNode.getTypeName().c_str(), preferredTextAccessibilityNode.getIntValue());
                }else
                {
                        cJSON_AddStringToObject(accessibility, preferredTextAccessibilityNode.getTypeName().c_str(), preferredTextAccessibilityNode.getStrValue().c_str());
                }
        }
        char *jsonStr = cJSON_Print(item);
        if (jsonStr)
        {
                preferrence.assign(jsonStr);
                free(jsonStr);
        }
        cJSON_Delete(item);
        return preferrence;
}
 
/**
 *   @brief get the current audio preference set by user
 */
std::string PrivateInstanceAAMP::GetPreferredAudioProperties()
{
        //Convert to JSON format
        std::string preferrence;
        cJSON *item;
        item = cJSON_CreateObject();
        if(!preferredLanguagesString.empty())
        {
                cJSON_AddStringToObject(item, "preferred-audio-languages", preferredLanguagesString.c_str());
        }
        if(!preferredLabelsString.empty())
        {
                cJSON_AddStringToObject(item, "preferred-audio-labels", preferredLabelsString.c_str());
        }
        if(!preferredCodecString.empty())
        {
                cJSON_AddStringToObject(item, "preferred-audio-codecs", preferredCodecString.c_str());
        }
        if(!preferredRenditionString.empty())
        {
                cJSON_AddStringToObject(item, "preferred-audio-rendition", preferredRenditionString.c_str());
        }
        if(!preferredTypeString.empty())
        {
                cJSON_AddStringToObject(item, "preferred-audio-type", preferredTypeString.c_str());
        }
        if(!preferredAudioAccessibilityNode.getSchemeId().empty())
        {
                cJSON * accessibility = cJSON_AddObjectToObject(item, "preferred-audio-accessibility");
                cJSON_AddStringToObject(accessibility, "schemeId", preferredAudioAccessibilityNode.getSchemeId().c_str());
                if (preferredAudioAccessibilityNode.getTypeName() == "int_value")
                {
                        cJSON_AddNumberToObject(accessibility, preferredAudioAccessibilityNode.getTypeName().c_str(), preferredAudioAccessibilityNode.getIntValue());
                }else
                {
                        cJSON_AddStringToObject(accessibility, preferredAudioAccessibilityNode.getTypeName().c_str(), preferredAudioAccessibilityNode.getStrValue().c_str());
                }
        }
        char *jsonStr = cJSON_Print(item);
        if (jsonStr)
        {
                preferrence.assign(jsonStr);
                free(jsonStr);
        }
        cJSON_Delete(item);
        return preferrence;
}
 
/**
 * @brief Get available video tracks.
 */
std::string PrivateInstanceAAMP::GetAvailableVideoTracks()
{
        std::string tracks;
 
        pthread_mutex_lock(&mStreamLock);
        if (mpStreamAbstractionAAMP)
        {
                std::vector <StreamInfo*> trackInfo = mpStreamAbstractionAAMP->GetAvailableVideoTracks();
                if (!trackInfo.empty())
                {
                        //Convert to JSON format
                        cJSON *root;
                        cJSON *item;
                        root = cJSON_CreateArray();
                        if(root)
                        {
                                for (int i = 0; i < trackInfo.size(); i++)
                                {
                                        cJSON_AddItemToArray(root, item = cJSON_CreateObject());
                                        if (trackInfo[i]->bandwidthBitsPerSecond != -1)
                                        {
                                                cJSON_AddNumberToObject(item, "bandwidth", trackInfo[i]->bandwidthBitsPerSecond);
                                        }
                                        if (trackInfo[i]->resolution.width != -1)
                                        {
                                                cJSON_AddNumberToObject(item, "width", trackInfo[i]->resolution.width);
                                        }
                                        if (trackInfo[i]->resolution.height != -1)
                                        {
                                                cJSON_AddNumberToObject(item, "height", trackInfo[i]->resolution.height);
                                        }
                                        if (trackInfo[i]->resolution.framerate != -1)
                                        {
                                                cJSON_AddNumberToObject(item, "framerate", trackInfo[i]->resolution.framerate);
                                        }
 
                                        cJSON_AddNumberToObject(item, "enabled", trackInfo[i]->enabled);
 
                                        if (trackInfo[i]->codecs)
                                        {
                                                cJSON_AddStringToObject(item, "codec", trackInfo[i]->codecs);
                                        }
                                }
                                char *jsonStr = cJSON_Print(root);
                                if (jsonStr)
                                {
                                        tracks.assign(jsonStr);
                                        free(jsonStr);
                                }
                                cJSON_Delete(root);
                        }
                }
                else
                {
                        AAMPLOG_ERR("PrivateInstanceAAMP: No available video track information!");
                }
        }
        pthread_mutex_unlock(&mStreamLock);
        return tracks;
}
 
/**
 * @brief  set birate for video tracks selection
 */
void PrivateInstanceAAMP::SetVideoTracks(std::vector<long> bitrateList)
{
        int bitrateSize = bitrateList.size();
        //clear cached bitrate list
        this->bitrateList.clear();
        // user profile stats enabled only for valid bitrate list, otherwise disabled for empty bitrates
        this->userProfileStatus = (bitrateSize > 0) ? true : false;
        AAMPLOG_INFO("User Profile filtering bitrate size:%d status:%d", bitrateSize, this->userProfileStatus);
        for (int i = 0; i < bitrateSize; i++)
        {
                this->bitrateList.push_back(bitrateList.at(i));
                AAMPLOG_WARN("User Profile Index : %d(%d) Bw : %ld", i, bitrateSize, bitrateList.at(i));
        }
        PrivAAMPState state;
        GetState(state);
        if (state > eSTATE_PREPARING)
        {
                AcquireStreamLock();
                TuneHelper(eTUNETYPE_RETUNE);
                ReleaseStreamLock();
        }
}
 
/**
 * @brief Get available audio tracks.
 */
std::string PrivateInstanceAAMP::GetAvailableAudioTracks(bool allTrack)
{
        std::string tracks;
 
        pthread_mutex_lock(&mStreamLock);
        if (mpStreamAbstractionAAMP)
        {
                std::vector<AudioTrackInfo> trackInfo = mpStreamAbstractionAAMP->GetAvailableAudioTracks(allTrack);
                if (!trackInfo.empty())
                {
                        //Convert to JSON format
                        cJSON *root;
                        cJSON *item;
                        cJSON *accessbilityArray = NULL;
                        root = cJSON_CreateArray();
                        if(root)
                        {
                                for (auto iter = trackInfo.begin(); iter != trackInfo.end(); iter++)
                                {
                                        cJSON_AddItemToArray(root, item = cJSON_CreateObject());
                                        if (!iter->name.empty())
                                        {
                                                cJSON_AddStringToObject(item, "name", iter->name.c_str());
                                        }
                                        if (!iter->label.empty())
                                        {
                                                cJSON_AddStringToObject(item, "label", iter->label.c_str());
                                        }
                                        if (!iter->language.empty())
                                        {
                                                cJSON_AddStringToObject(item, "language", iter->language.c_str());
                                        }
                                        if (!iter->codec.empty())
                                        {
                                                cJSON_AddStringToObject(item, "codec", iter->codec.c_str());
                                        }
                                        if (!iter->rendition.empty())
                                        {
                                                cJSON_AddStringToObject(item, "rendition", iter->rendition.c_str());
                                        }
                                        if (!iter->accessibilityType.empty())
                                        {
                                                cJSON_AddStringToObject(item, "accessibilityType", iter->accessibilityType.c_str());
                                        }
                                        if (!iter->characteristics.empty())
                                        {
                                                cJSON_AddStringToObject(item, "characteristics", iter->characteristics.c_str());
                                        }
                                        if (iter->channels != 0)
                                        {
                                                cJSON_AddNumberToObject(item, "channels", iter->channels);
                                        }
                                        if (iter->bandwidth != -1)
                                        {
                                                cJSON_AddNumberToObject(item, "bandwidth", iter->bandwidth);
                                        }
                                        if (!iter->contentType.empty())
                                        {
                                                cJSON_AddStringToObject(item, "contentType", iter->contentType.c_str());
                                        }
                                        if (!iter->mixType.empty())
                                        {
                                                cJSON_AddStringToObject(item, "mixType", iter->mixType.c_str());
                                        }
                                        if (!iter->mType.empty())
                                        {
                                                cJSON_AddStringToObject(item, "Type", iter->mType.c_str());
                                        }
                                        cJSON_AddBoolToObject(item, "availability", iter->isAvailable);
                                        if (!iter->accessibilityItem.getSchemeId().empty())
                                        {
                                                cJSON *accessibility = cJSON_AddObjectToObject(item, "accessibility");
                                                cJSON_AddStringToObject(accessibility, "scheme", iter->accessibilityItem.getSchemeId().c_str());
                                                std::string valueType = iter->accessibilityItem.getTypeName();
                                                if (valueType == "int_value")
                                                {
                                                        cJSON_AddNumberToObject(accessibility, valueType.c_str(), iter->accessibilityItem.getIntValue());
                                                }else
                                                {
                                                        cJSON_AddStringToObject(accessibility, valueType.c_str(), iter->accessibilityItem.getStrValue().c_str());
                                                }
                                        }
                                }
                                char *jsonStr = cJSON_Print(root);
                                if (jsonStr)
                                {
                                        tracks.assign(jsonStr);
                                        free(jsonStr);
                                }
                                cJSON_Delete(root);
                        }
                }
                else
                {
                        AAMPLOG_ERR("PrivateInstanceAAMP: No available audio track information!");
                }
        }
        pthread_mutex_unlock(&mStreamLock);
        return tracks;
}
 
/**
 *   @brief Get available text tracks.
 */
std::string PrivateInstanceAAMP::GetAvailableTextTracks(bool allTrack)
{
        std::string tracks;
 
        pthread_mutex_lock(&mStreamLock);
        if (mpStreamAbstractionAAMP)
        {
                std::vector<TextTrackInfo> trackInfo = mpStreamAbstractionAAMP->GetAvailableTextTracks(allTrack);
 
#ifdef AAMP_CC_ENABLED
                std::vector<TextTrackInfo> textTracksCopy;
                std::copy_if(begin(trackInfo), end(trackInfo), back_inserter(textTracksCopy), [](const TextTrackInfo& e){return e.isCC;});
                AampCCManager::GetInstance()->updateLastTextTracks(textTracksCopy);
#endif
                if (!trackInfo.empty())
                {
                        //Convert to JSON format
                        cJSON *root;
                        cJSON *item;
                        root = cJSON_CreateArray();
                        if(root)
                        {
                                for (auto iter = trackInfo.begin(); iter != trackInfo.end(); iter++)
                                {
                                        cJSON_AddItemToArray(root, item = cJSON_CreateObject());
                                        if (!iter->name.empty())
                                        {
                                                cJSON_AddStringToObject(item, "name", iter->name.c_str());
                                        }
                                        if (!iter->label.empty())
                                        {
                                                cJSON_AddStringToObject(item, "label", iter->label.c_str());
                                        }
                                        if (iter->isCC)
                                        {
                                                cJSON_AddStringToObject(item, "sub-type", "CLOSED-CAPTIONS");
                                        }
                                        else
                                        {
                                                cJSON_AddStringToObject(item, "sub-type", "SUBTITLES");
                                        }
                                        if (!iter->language.empty())
                                        {
                                                cJSON_AddStringToObject(item, "language", iter->language.c_str());
                                        }
                                        if (!iter->rendition.empty())
                                        {
                                                cJSON_AddStringToObject(item, "rendition", iter->rendition.c_str());
                                        }
                                        if (!iter->accessibilityType.empty())
                                        {
                                                cJSON_AddStringToObject(item, "accessibilityType", iter->accessibilityType.c_str());
                                        }
                                        if (!iter->instreamId.empty())
                                        {
                                                cJSON_AddStringToObject(item, "instreamId", iter->instreamId.c_str());
                                        }
                                        if (!iter->characteristics.empty())
                                        {
                                                cJSON_AddStringToObject(item, "characteristics", iter->characteristics.c_str());
                                        }
                                        if (!iter->mType.empty())
                                        {
                                                cJSON_AddStringToObject(item, "type", iter->mType.c_str());
                                        }
                                        if (!iter->codec.empty())
                                        {
                                                cJSON_AddStringToObject(item, "codec", iter->codec.c_str());
                                        }
                                        cJSON_AddBoolToObject(item, "availability", iter->isAvailable);
                                        if (!iter->accessibilityItem.getSchemeId().empty())
                                        {
                                                cJSON *accessibility = cJSON_AddObjectToObject(item, "accessibility");
                                                cJSON_AddStringToObject(accessibility, "scheme", iter->accessibilityItem.getSchemeId().c_str());
                                                
                                                std::string valueType = iter->accessibilityItem.getTypeName();
                                                if (valueType == "int_value")
                                                {
                                                        cJSON_AddNumberToObject(accessibility, valueType.c_str(), iter->accessibilityItem.getIntValue());
 
                                                }else
                                                {
                                                        cJSON_AddStringToObject(accessibility, valueType.c_str(), iter->accessibilityItem.getStrValue().c_str());
                                                }
                                        }
                                }
                                char *jsonStr = cJSON_Print(root);
                                if (jsonStr)
                                {
                                        tracks.assign(jsonStr);
                                        free(jsonStr);
                                }
                                cJSON_Delete(root);
                        }
                }
                else
                {
                        AAMPLOG_ERR("PrivateInstanceAAMP: No available text track information!");
                }
        }
        pthread_mutex_unlock(&mStreamLock);
        return tracks;
}
 
/*
 * @brief Get the video window co-ordinates
 */
std::string PrivateInstanceAAMP::GetVideoRectangle()
{
        return mStreamSink->GetVideoRectangle();
}
 
/**
 * @brief Set the application name which has created PlayerInstanceAAMP, for logging purposes
 */
void PrivateInstanceAAMP::SetAppName(std::string name)
{
        mAppName = name;
}
 
/**
 *   @brief Get the application name
 */
std::string PrivateInstanceAAMP::GetAppName()
{
        return mAppName;
}
 
/**
 * @brief DRM individualization callback
 */
void PrivateInstanceAAMP::individualization(const std::string& payload)
{
        DrmMessageEventPtr event = std::make_shared<DrmMessageEvent>(payload);
        SendEvent(event,AAMP_EVENT_ASYNC_MODE);
}
 
/**
 * @brief Get current initial buffer duration in seconds
 */
int PrivateInstanceAAMP::GetInitialBufferDuration()
{
        GETCONFIGVALUE_PRIV(eAAMPConfig_InitialBuffer,mMinInitialCacheSeconds);
        return mMinInitialCacheSeconds;
}
 
/**
 *   @brief Check if First Video Frame Displayed Notification
 *          is required.
 */
bool PrivateInstanceAAMP::IsFirstVideoFrameDisplayedRequired()
{
        return mFirstVideoFrameDisplayedEnabled;
}
 
/**
 *   @brief Notify First Video Frame was displayed
 */
void PrivateInstanceAAMP::NotifyFirstVideoFrameDisplayed()
{
        if(!mFirstVideoFrameDisplayedEnabled)
        {
                return;
        }
 
        mFirstVideoFrameDisplayedEnabled = false;
 
        // In the middle of stop processing we can receive state changing callback (xione-7331)
        PrivAAMPState state;
        GetState(state);
        if (state == eSTATE_IDLE)
        {
                AAMPLOG_WARN( "skipped as in IDLE state" );
                return;
        }
        
        // Seek While Paused - pause on first Video frame displayed
        if(mPauseOnFirstVideoFrameDisp)
        {
                mPauseOnFirstVideoFrameDisp = false;
                PrivAAMPState state;
                GetState(state);
                if(state != eSTATE_SEEKING)
                {
                        return;
                }
 
                AAMPLOG_INFO("Pausing Playback on First Frame Displayed");
                if(mpStreamAbstractionAAMP)
                {
                        mpStreamAbstractionAAMP->NotifyPlaybackPaused(true);
                }
                StopDownloads();
                if(PausePipeline(true, false))
                {
                        SetState(eSTATE_PAUSED);
                }
                else
                {
                        AAMPLOG_ERR("Failed to pause pipeline for first frame displayed!");
                }
        }
        // Otherwise check for setting BUFFERING state
        else if(!SetStateBufferingIfRequired())
        {
                // If Buffering state was not needed, set PLAYING state
                SetState(eSTATE_PLAYING);
        }
}
 
/**
 * @brief Set eSTATE_BUFFERING if required
 */
bool PrivateInstanceAAMP::SetStateBufferingIfRequired()
{
        bool bufferingSet = false;
 
        pthread_mutex_lock(&mFragmentCachingLock);
        if(IsFragmentCachingRequired())
        {
                bufferingSet = true;
                PrivAAMPState state;
                GetState(state);
                if(state != eSTATE_BUFFERING)
                {
                        if(mpStreamAbstractionAAMP)
                        {
                                mpStreamAbstractionAAMP->NotifyPlaybackPaused(true);
                        }
 
                        if(mStreamSink)
                        {
                                mStreamSink->NotifyFragmentCachingOngoing();
                        }
                        SetState(eSTATE_BUFFERING);
                }
        }
        pthread_mutex_unlock(&mFragmentCachingLock);
 
        return bufferingSet;
}
 
/**
 * @brief Check to media track downloads are enabled
 */
bool PrivateInstanceAAMP::TrackDownloadsAreEnabled(MediaType type)
{
        bool ret = true;
        if (type >= AAMP_TRACK_COUNT)  //CID:142718 - overrun
        {
                AAMPLOG_ERR("type[%d] is un-supported, returning default as false!", type);
                ret = false;
        }
        else
        {
                pthread_mutex_lock(&mLock);
                // If blocked, track downloads are disabled
                ret = !mbTrackDownloadsBlocked[type];
                pthread_mutex_unlock(&mLock);
        }
        return ret;
}
 
/**
 * @brief Stop buffering in AAMP and un-pause pipeline.
 */
void PrivateInstanceAAMP::StopBuffering(bool forceStop)
{
        mStreamSink->StopBuffering(forceStop);
}
 
/**
 * @brief Get license server url for a drm type
 */
std::string PrivateInstanceAAMP::GetLicenseServerUrlForDrm(DRMSystems type)
{
        std::string url;
        if (type == eDRM_PlayReady)
        {
                GETCONFIGVALUE_PRIV(eAAMPConfig_PRLicenseServerUrl,url);
        }
        else if (type == eDRM_WideVine)
        {       
                GETCONFIGVALUE_PRIV(eAAMPConfig_WVLicenseServerUrl,url);
        }
        else if (type == eDRM_ClearKey)
        {
                GETCONFIGVALUE_PRIV(eAAMPConfig_CKLicenseServerUrl,url);
        }
 
        if(url.empty())
        {
                GETCONFIGVALUE_PRIV(eAAMPConfig_LicenseServerUrl,url);
        }
        return url;
}
 
/**
 * @brief Get current audio track index
 */
int PrivateInstanceAAMP::GetAudioTrack()
{
        int idx = -1;
        AcquireStreamLock();
        if (mpStreamAbstractionAAMP)
        {
                idx = mpStreamAbstractionAAMP->GetAudioTrack();
        }
        ReleaseStreamLock();
        return idx;
}
 
/**
 * @brief Get current audio track index
 */
std::string PrivateInstanceAAMP::GetAudioTrackInfo()
{
        std::string track;
        
 
        pthread_mutex_lock(&mStreamLock);
        if (mpStreamAbstractionAAMP)
        {
                AudioTrackInfo trackInfo;
                if (mpStreamAbstractionAAMP->GetCurrentAudioTrack(trackInfo))
                {
                        //Convert to JSON format
                        cJSON *root;
                        cJSON *item;
                        root = cJSON_CreateArray();
                        if(root)
                        {
                                cJSON_AddItemToArray(root, item = cJSON_CreateObject());
                                if (!trackInfo.name.empty())
                                {
                                        cJSON_AddStringToObject(item, "name", trackInfo.name.c_str());
                                }
                                if (!trackInfo.language.empty())
                                {
                                        cJSON_AddStringToObject(item, "language", trackInfo.language.c_str());
                                }
                                if (!trackInfo.codec.empty())
                                {
                                        cJSON_AddStringToObject(item, "codec", trackInfo.codec.c_str());
                                }
                                if (!trackInfo.rendition.empty())
                                {
                                        cJSON_AddStringToObject(item, "rendition", trackInfo.rendition.c_str());
                                }
                                if (!trackInfo.label.empty())
                                {
                                        cJSON_AddStringToObject(item, "label", trackInfo.label.c_str());
                                }
                                if (!trackInfo.accessibilityType.empty())
                                {
                                        cJSON_AddStringToObject(item, "accessibilityType", trackInfo.accessibilityType.c_str());
                                }
                                if (!trackInfo.characteristics.empty())
                                {
                                        cJSON_AddStringToObject(item, "characteristics", trackInfo.characteristics.c_str());
                                }
                                if (trackInfo.channels != 0)
                                {
                                        cJSON_AddNumberToObject(item, "channels", trackInfo.channels);
                                }
                                if (trackInfo.bandwidth != -1)
                                {
                                        cJSON_AddNumberToObject(item, "bandwidth", trackInfo.bandwidth);
                                }
                                if (!trackInfo.contentType.empty())
                                {
                                        cJSON_AddStringToObject(item, "contentType", trackInfo.contentType.c_str());
                                }
                                if (!trackInfo.mixType.empty())
                                {
                                        cJSON_AddStringToObject(item, "mixType", trackInfo.mixType.c_str());
                                }
                                if (!trackInfo.mType.empty())
                                {
                                        cJSON_AddStringToObject(item, "type", trackInfo.mType.c_str());
                                }
                                if (!trackInfo.accessibilityItem.getSchemeId().empty())
                                {
                                        cJSON *accessibility = cJSON_AddObjectToObject(item, "accessibility");
                                        cJSON_AddStringToObject(accessibility, "scheme", trackInfo.accessibilityItem.getSchemeId().c_str());
                                        if (trackInfo.accessibilityItem.getTypeName() == "int_value")
                                        {
                                                cJSON_AddNumberToObject(accessibility, trackInfo.accessibilityItem.getTypeName().c_str(), trackInfo.accessibilityItem.getIntValue());
                                        }
                                        else
                                        {
                                                cJSON_AddStringToObject(accessibility, trackInfo.accessibilityItem.getTypeName().c_str(), trackInfo.accessibilityItem.getStrValue().c_str());
                                        }
                                }
                                char *jsonStr = cJSON_Print(root);
                                if (jsonStr)
                                {
                                        track.assign(jsonStr);
                                        free(jsonStr);
                                }
                                cJSON_Delete(root);
                        }
                }
                else
                {
                        AAMPLOG_ERR("PrivateInstanceAAMP: No available Text track information!");
                }
        }
        else
        {
                AAMPLOG_ERR("PrivateInstanceAAMP: Not in playing state!");
        }
        pthread_mutex_unlock(&mStreamLock);
        return track;
}
 
/**
 * @brief Get current audio track index
 */
std::string PrivateInstanceAAMP::GetTextTrackInfo()
{
        std::string track;
        pthread_mutex_lock(&mStreamLock);
        if (mpStreamAbstractionAAMP)
        {
                TextTrackInfo trackInfo;
                if (mpStreamAbstractionAAMP->GetCurrentTextTrack(trackInfo))
                {
                        //Convert to JSON format
                        cJSON *root;
                        cJSON *item;
                        root = cJSON_CreateArray();
                        if(root)
                        {
                                cJSON_AddItemToArray(root, item = cJSON_CreateObject());
                                if (!trackInfo.name.empty())
                                {
                                        cJSON_AddStringToObject(item, "name", trackInfo.name.c_str());
                                }
                                if (!trackInfo.language.empty())
                                {
                                        cJSON_AddStringToObject(item, "language", trackInfo.language.c_str());
                                }
                                if (!trackInfo.codec.empty())
                                {
                                        cJSON_AddStringToObject(item, "codec", trackInfo.codec.c_str());
                                }
                                if (!trackInfo.rendition.empty())
                                {
                                        cJSON_AddStringToObject(item, "rendition", trackInfo.rendition.c_str());
                                }
                                if (!trackInfo.label.empty())
                                {
                                        cJSON_AddStringToObject(item, "label", trackInfo.label.c_str());
                                }
                                if (!trackInfo.accessibilityType.empty())
                                {
                                        cJSON_AddStringToObject(item, "accessibilityType", trackInfo.accessibilityType.c_str());
                                }
                                if (!trackInfo.characteristics.empty())
                                {
                                        cJSON_AddStringToObject(item, "characteristics", trackInfo.characteristics.c_str());
                                }
                                if (!trackInfo.mType.empty())
                                {
                                        cJSON_AddStringToObject(item, "type", trackInfo.mType.c_str());
                                }
                                if (!trackInfo.accessibilityItem.getSchemeId().empty())
                                {
                                        cJSON *accessibility = cJSON_AddObjectToObject(item, "accessibility");
                                        cJSON_AddStringToObject(accessibility, "scheme", trackInfo.accessibilityItem.getSchemeId().c_str());
                                        if (trackInfo.accessibilityItem.getTypeName() == "int_value")
                                        {
                                                cJSON_AddNumberToObject(accessibility, trackInfo.accessibilityItem.getTypeName().c_str(), trackInfo.accessibilityItem.getIntValue());
                                        }
                                        else
                                        {
                                                cJSON_AddStringToObject(accessibility, trackInfo.accessibilityItem.getTypeName().c_str(), trackInfo.accessibilityItem.getStrValue().c_str());
                                        }
                                }
                                char *jsonStr = cJSON_Print(root);
                                if (jsonStr)
                                {
                                        track.assign(jsonStr);
                                        free(jsonStr);
                                }
                                cJSON_Delete(root);
                        }
                }
                else
                {
                        AAMPLOG_ERR("PrivateInstanceAAMP: No available Text track information!");
                }
        }
        else
        {
                AAMPLOG_ERR("PrivateInstanceAAMP: Not in playing state!");
        }
        pthread_mutex_unlock(&mStreamLock);
        return track;
}
 
 
/**
 * @brief Create json data from track Info
 */
static char* createJsonData(TextTrackInfo& track)
{
        char *jsonStr = NULL;
        cJSON *item = cJSON_CreateObject();
        if (!track.name.empty())
        {
                cJSON_AddStringToObject(item, "name", track.name.c_str());
        }
        if (!track.language.empty())
        {
                cJSON_AddStringToObject(item, "languages", track.language.c_str());
        }
        if (!track.codec.empty())
        {
                cJSON_AddStringToObject(item, "codec", track.codec.c_str());
        }
        if (!track.rendition.empty())
        {
                cJSON_AddStringToObject(item, "rendition", track.rendition.c_str());
        }
        if (!track.label.empty())
        {
                cJSON_AddStringToObject(item, "label", track.label.c_str());
        }
        if (!track.accessibilityType.empty())
        {
                cJSON_AddStringToObject(item, "accessibilityType", track.accessibilityType.c_str());
        }
        if (!track.characteristics.empty())
        {
                cJSON_AddStringToObject(item, "characteristics", track.characteristics.c_str());
        }
        if (!track.mType.empty())
        {
                cJSON_AddStringToObject(item, "type", track.mType.c_str());
        }
        if (!track.accessibilityItem.getSchemeId().empty())
        {
                cJSON *accessibility = cJSON_AddObjectToObject(item, "accessibility");
                cJSON_AddStringToObject(accessibility, "scheme", track.accessibilityItem.getSchemeId().c_str());
                if (track.accessibilityItem.getTypeName() == "int_value")
                {
                        cJSON_AddNumberToObject(accessibility, track.accessibilityItem.getTypeName().c_str(), track.accessibilityItem.getIntValue());
                }
                else
                {
                        cJSON_AddStringToObject(accessibility, track.accessibilityItem.getTypeName().c_str(), track.accessibilityItem.getStrValue().c_str());
                }
        }
        
        jsonStr = cJSON_Print(item);
        cJSON_Delete(item);
        return jsonStr;
}
 
/**
 * @brief Set text track
 */
void PrivateInstanceAAMP::SetTextTrack(int trackId, char *data)
{
        AAMPLOG_INFO("trackId: %d", trackId);
        if (mpStreamAbstractionAAMP)
        {
                // Passing in -1 as the track ID mutes subs
                if (MUTE_SUBTITLES_TRACKID == trackId)
                {
                        SetCCStatus(false);
                        return;
                }
 
                if (data == NULL)
                {
                        std::vector<TextTrackInfo> tracks = mpStreamAbstractionAAMP->GetAvailableTextTracks();
                        if (!tracks.empty() && (trackId >= 0 && trackId < tracks.size()))
                        {
                                TextTrackInfo track = tracks[trackId];
                                // Check if CC / Subtitle track
                                if (track.isCC)
                                {
                                        mIsInbandCC = true;
#ifdef AAMP_CC_ENABLED
                                        if (!track.instreamId.empty())
                                        {
                                                CCFormat format = eCLOSEDCAPTION_FORMAT_DEFAULT;
                                                // AampCCManager expects the CC type, ie 608 or 708
                                                // For DASH, there is a possibility that instreamId is just an integer so we infer rendition
                                                if (mMediaFormat == eMEDIAFORMAT_DASH && (std::isdigit(static_cast<unsigned char>(track.instreamId[0])) == 0) && !track.rendition.empty())
                                                {
                                                        if (track.rendition.find("608") != std::string::npos)
                                                        {
                                                                format = eCLOSEDCAPTION_FORMAT_608;
                                                        }
                                                        else if (track.rendition.find("708") != std::string::npos)
                                                        {
                                                                format = eCLOSEDCAPTION_FORMAT_708;
                                                        }
                                                }       
 
                                                // preferredCEA708 overrides whatever we infer from track. USE WITH CAUTION
                                                int overrideCfg;
                                                GETCONFIGVALUE_PRIV(eAAMPConfig_CEAPreferred,overrideCfg);
                                                if (overrideCfg != -1)
                                                {
                                                        format = (CCFormat)(overrideCfg & 1);
                                                        AAMPLOG_WARN("PrivateInstanceAAMP: CC format override present, override format to: %d", format);
                                                }       
                                                AampCCManager::GetInstance()->SetTrack(track.instreamId, format);
                                        }
                                        else
                                        {
                                                AAMPLOG_ERR("PrivateInstanceAAMP: Track number/instreamId is empty, skip operation");
                                        }
#endif
                                }
                                else
                                {
                                        mIsInbandCC = false;
                                        //Unmute subtitles
                                        SetCCStatus(true);
 
                                        //TODO: Effective handling between subtitle and CC tracks
                                        int textTrack = mpStreamAbstractionAAMP->GetTextTrack();
                                        AAMPLOG_WARN("GetPreferredTextTrack %d trackId %d", textTrack, trackId);
                                        if (trackId != textTrack)
                                        {
                                                if(mMediaFormat == eMEDIAFORMAT_DASH)
                                                {
                                                        const char* jsonData = createJsonData(track);
                                                        if(NULL != jsonData)
                                                        { 
                                                                SetPreferredTextLanguages(jsonData);
                                                        }
                                                }
                                                else
                                                {
                                                        SetPreferredTextTrack(track);
                                                        discardEnteringLiveEvt = true;
                                                        seek_pos_seconds = GetPositionSeconds();
                                                        AcquireStreamLock();
                                                        TeardownStream(false);
                                                        TuneHelper(eTUNETYPE_SEEK);
                                                        ReleaseStreamLock();
                                                        discardEnteringLiveEvt = false;
                                                }
                                        }
                                }
                        }
                }
                else
                {
                        AAMPLOG_WARN("webvtt data received from application");
                        mData = data;
                        SetCCStatus(true);
 
                        mpStreamAbstractionAAMP->InitSubtitleParser(data);
                        if (!mTextStyle.empty())
                        {
                                // Restore the subtitle text style after a track change.
                                (void)mpStreamAbstractionAAMP->SetTextStyle(mTextStyle);
                        }
                }
        }
}
 
 
/**
 * @brief Switch the subtitle track following a change to the 
 *                      preferredTextTrack
 */
void PrivateInstanceAAMP::RefreshSubtitles()
{
        if (mpStreamAbstractionAAMP)
        {
                mpStreamAbstractionAAMP->RefreshSubtitles();
        }
}
 
/**
 * @brief Get current text track index
 */
int PrivateInstanceAAMP::GetTextTrack()
{
        int idx = -1;
        AcquireStreamLock();
#ifdef AAMP_CC_ENABLED
        if (AampCCManager::GetInstance()->GetStatus() && mpStreamAbstractionAAMP)
        {
                std::string trackId = AampCCManager::GetInstance()->GetTrack();
                if (!trackId.empty())
                {
                        std::vector<TextTrackInfo> tracks = mpStreamAbstractionAAMP->GetAvailableTextTracks();
                        for (auto it = tracks.begin(); it != tracks.end(); it++)
                        {
                                if (it->instreamId == trackId)
                                {
                                        idx = std::distance(tracks.begin(), it);
                                }
                        }
                }
        }
#endif
        if (mpStreamAbstractionAAMP && idx == -1 && !subtitles_muted)
        {
                idx = mpStreamAbstractionAAMP->GetTextTrack();
        }
        ReleaseStreamLock();
        return idx;
}
 
/**
 * @brief Set CC visibility on/off
 */
void PrivateInstanceAAMP::SetCCStatus(bool enabled)
{
#ifdef AAMP_CC_ENABLED
        AampCCManager::GetInstance()->SetStatus(enabled);
#endif
        AcquireStreamLock();
        subtitles_muted = !enabled;
        if (mpStreamAbstractionAAMP)
        {
                mpStreamAbstractionAAMP->MuteSubtitles(subtitles_muted);
                if (HasSidecarData())
                { // has sidecar data
                        mpStreamAbstractionAAMP->MuteSidecarSubtitles(subtitles_muted);
                }
        }
        SetSubtitleMute(subtitles_muted);
        ReleaseStreamLock();
}
 
/**
 * @brief Get CC visibility on/off
 */
bool PrivateInstanceAAMP::GetCCStatus(void)
{
        return !(subtitles_muted);
}
 
/**
 * @brief Function to notify available audio tracks changed
 */
void PrivateInstanceAAMP::NotifyAudioTracksChanged()
{
        SendEvent(std::make_shared<AAMPEventObject>(AAMP_EVENT_AUDIO_TRACKS_CHANGED),AAMP_EVENT_ASYNC_MODE);
}
 
/**
 * @brief Function to notify available text tracks changed
 */
void PrivateInstanceAAMP::NotifyTextTracksChanged()
{
        SendEvent(std::make_shared<AAMPEventObject>(AAMP_EVENT_TEXT_TRACKS_CHANGED),AAMP_EVENT_ASYNC_MODE);
}
 
/**
 * @brief Set style options for text track rendering
 *
 */
void PrivateInstanceAAMP::SetTextStyle(const std::string &options)
{
        bool retVal = false;
 
        mTextStyle = options;
 
        if (mpStreamAbstractionAAMP)
        {
                AAMPLOG_WARN("Calling StreamAbstractionAAMP::SetTextStyle(%s)", options.c_str());
                retVal = mpStreamAbstractionAAMP->SetTextStyle(options);
        }
        if (!retVal)
        {
#ifdef AAMP_CC_ENABLED
                AAMPLOG_WARN("Calling AampCCManager::SetTextStyle(%s)", options.c_str());
                AampCCManager::GetInstance()->SetStyle(options);
#endif
        }
}
 
/**
 * @brief Get style options for text track rendering
 */
std::string PrivateInstanceAAMP::GetTextStyle()
{
        return mTextStyle;
}
 
/**
 * @brief Check if any active PrivateInstanceAAMP available
 */
bool PrivateInstanceAAMP::IsActiveInstancePresent()
{
        return !gActivePrivAAMPs.empty();
}
 
/**
 *  @brief Set discontinuity ignored flag for given track
 */
void PrivateInstanceAAMP::SetTrackDiscontinuityIgnoredStatus(MediaType track)
{
        mIsDiscontinuityIgnored[track] = true;
}
 
/**
 *  @brief Check whether the given track discontinuity ignored earlier.
 */
bool PrivateInstanceAAMP::IsDiscontinuityIgnoredForOtherTrack(MediaType track)
{
        return (mIsDiscontinuityIgnored[track]);
}
 
/**
 *  @brief Reset discontinuity ignored flag for audio and video tracks
 */
void PrivateInstanceAAMP::ResetTrackDiscontinuityIgnoredStatus(void)
{
        mIsDiscontinuityIgnored[eTRACK_VIDEO] = false;
        mIsDiscontinuityIgnored[eTRACK_AUDIO] = false;
}
 
/**
 * @brief Set stream format for audio/video tracks
 */
void PrivateInstanceAAMP::SetStreamFormat(StreamOutputFormat videoFormat, StreamOutputFormat audioFormat, StreamOutputFormat auxFormat)
{
        bool reconfigure = false;
        AAMPLOG_WARN("Got format - videoFormat %d and audioFormat %d", videoFormat, audioFormat);
 
        // 1. Modified Configure() not to recreate all playbins if there is a change in track's format.
        // 2. For a demuxed scenario, this function will be called twice for each audio and video, so double the trouble.
        // Hence call Configure() only for following scenarios to reduce the overhead,
        // i.e FORMAT_INVALID to any KNOWN/FORMAT_UNKNOWN, FORMAT_UNKNOWN to any KNOWN and any FORMAT_KNOWN to FORMAT_KNOWN if it's not same.
        // Truth table
        // mVideFormat   videoFormat  reconfigure
        // *              INVALID       false
        // INVALID        INVALID       false
        // INVALID        UNKNOWN       true
        // INVALID        KNOWN         true
        // UNKNOWN        INVALID       false
        // UNKNOWN        UNKNOWN       false
        // UNKNOWN        KNOWN         true
        // KNOWN          INVALID       false
        // KNOWN          UNKNOWN       false
        // KNOWN          KNOWN         true if format changes, false if same
        pthread_mutex_lock(&mLock);
        if (videoFormat != FORMAT_INVALID && mVideoFormat != videoFormat && (videoFormat != FORMAT_UNKNOWN || mVideoFormat == FORMAT_INVALID))
        {
                reconfigure = true;
                mVideoFormat = videoFormat;
        }
        if (audioFormat != FORMAT_INVALID && mAudioFormat != audioFormat && (audioFormat != FORMAT_UNKNOWN || mAudioFormat == FORMAT_INVALID))
        {
                reconfigure = true;
                mAudioFormat = audioFormat;
        }
        if (auxFormat != mAuxFormat && (mAuxFormat == FORMAT_INVALID || (mAuxFormat != FORMAT_UNKNOWN && auxFormat != FORMAT_UNKNOWN)) && auxFormat != FORMAT_INVALID)
        {
                reconfigure = true;
                mAuxFormat = auxFormat;
        }
        if (IsMuxedStream() && (mVideoComponentCount == 0 || mAudioComponentCount == 0)) //Can be a Muxed stream/Demuxed with either of audio or video-only stream
        {
                AAMPLOG_INFO(" TS Processing Done. Number of Audio Components : %d and Video Components : %d",mAudioComponentCount,mVideoComponentCount);
                if (IsAudioOrVideoOnly(videoFormat, audioFormat, auxFormat))
                {
                        bool newTune = IsNewTune();
                        pthread_mutex_unlock(&mLock);
                        mStreamSink->Stop(!newTune);
                        pthread_mutex_lock(&mLock);
                        reconfigure = true;
                }
        }
        if (reconfigure)
        {
                // Configure pipeline as TSProcessor might have detected the actual stream type
                // or even presence of audio
                mStreamSink->Configure(mVideoFormat, mAudioFormat, mAuxFormat, mSubtitleFormat, false, mpStreamAbstractionAAMP->GetAudioFwdToAuxStatus());
        }
        pthread_mutex_unlock(&mLock);
}
 
/**
 * @brief To check for audio/video only Playback
 */
 
bool PrivateInstanceAAMP::IsAudioOrVideoOnly(StreamOutputFormat videoFormat, StreamOutputFormat audioFormat, StreamOutputFormat auxFormat)
{
        AAMPLOG_WARN("Old Stream format - videoFormat %d and audioFormat %d",mVideoFormat,mAudioFormat);
        bool ret = false;
        if (mVideoComponentCount == 0 && (mVideoFormat != videoFormat && videoFormat == FORMAT_INVALID))
        {
                mAudioOnlyPb = true;
                mVideoFormat = videoFormat;
                AAMPLOG_INFO("Audio-Only PlayBack");
                ret = true;
        }
 
        else if (mAudioComponentCount == 0)
        {
                if (mAudioFormat != audioFormat && audioFormat == FORMAT_INVALID)
                {
                        mAudioFormat = audioFormat;
                }
                else if (mAuxFormat != auxFormat && auxFormat == FORMAT_INVALID)
                {
                        mAuxFormat = auxFormat;
                }
                mVideoOnlyPb = true;
                AAMPLOG_INFO("Video-Only PlayBack");
                ret = true;
        }
 
        return ret;
}
/**
 *  @brief Disable Content Restrictions - unlock
 */
void PrivateInstanceAAMP::DisableContentRestrictions(long grace, long time, bool eventChange)
{
        AcquireStreamLock();
        if (mpStreamAbstractionAAMP)
        {
                mpStreamAbstractionAAMP->DisableContentRestrictions(grace, time, eventChange);
#ifdef AAMP_CC_ENABLED
                if (ISCONFIGSET_PRIV(eAAMPConfig_NativeCCRendering))
                {
                        AampCCManager::GetInstance()->SetParentalControlStatus(false);
                }
#endif
        }
        ReleaseStreamLock();
}
 
/**
 *  @brief Enable Content Restrictions - lock
 */
void PrivateInstanceAAMP::EnableContentRestrictions()
{
        AcquireStreamLock();
        if (mpStreamAbstractionAAMP)
        {
                mpStreamAbstractionAAMP->EnableContentRestrictions();
        }
        ReleaseStreamLock();
}
 
 
/**
 *  @brief Add async task to scheduler
 */
int PrivateInstanceAAMP::ScheduleAsyncTask(IdleTask task, void *arg, std::string taskName)
{
        int taskId = AAMP_TASK_ID_INVALID;
        if (mScheduler)
        {
                taskId = mScheduler->ScheduleTask(AsyncTaskObj(task, arg, taskName));
                if (taskId == AAMP_TASK_ID_INVALID)
                {
                        AAMPLOG_ERR("mScheduler returned invalid ID, dropping the schedule request!");
                }
        }
        else
        {
                taskId = g_idle_add(task, (gpointer)arg);
        }
        return taskId;
}
 
/**
 * @brief Remove async task scheduled earlier
 */
bool PrivateInstanceAAMP::RemoveAsyncTask(int taskId)
{
        bool ret = false;
        if (mScheduler)
        {
                ret = mScheduler->RemoveTask(taskId);
        }
        else
        {
                ret = g_source_remove(taskId);
        }
        return ret;
}
 
 
/**
 *  @brief acquire streamsink lock
 */
void PrivateInstanceAAMP::AcquireStreamLock()
{
        pthread_mutex_lock(&mStreamLock);
}
 
/**
 * @brief try to acquire streamsink lock
 *
 */
bool PrivateInstanceAAMP::TryStreamLock()
{
        return (pthread_mutex_trylock(&mStreamLock) == 0);
}
 
/**
 * @brief release streamsink lock
 *
 */
void PrivateInstanceAAMP::ReleaseStreamLock()
{
        pthread_mutex_unlock(&mStreamLock);
}
 
/**
 * @brief To check if auxiliary audio is enabled
 */
bool PrivateInstanceAAMP::IsAuxiliaryAudioEnabled(void)
{
        return !mAuxAudioLanguage.empty();
}
 
/**
 * @brief Check if discontinuity processed in all tracks
 *
 */
bool PrivateInstanceAAMP::DiscontinuitySeenInAllTracks()
{
        // Check if track is disabled or if mProcessingDiscontinuity is set
        // Split off the logical expression for better clarity
        bool vidDiscontinuity = (mVideoFormat == FORMAT_INVALID || mProcessingDiscontinuity[eMEDIATYPE_VIDEO]);
        bool audDiscontinuity = (mAudioFormat == FORMAT_INVALID || mProcessingDiscontinuity[eMEDIATYPE_AUDIO]);
        bool auxDiscontinuity = (mAuxFormat == FORMAT_INVALID || mProcessingDiscontinuity[eMEDIATYPE_AUX_AUDIO]);
 
        return (vidDiscontinuity && auxDiscontinuity && auxDiscontinuity);
}
 
/**
 *   @brief Check if discontinuity processed in any track
 */
bool PrivateInstanceAAMP::DiscontinuitySeenInAnyTracks()
{
        // Check if track is enabled and if mProcessingDiscontinuity is set
        // Split off the logical expression for better clarity
        bool vidDiscontinuity = (mVideoFormat != FORMAT_INVALID && mProcessingDiscontinuity[eMEDIATYPE_VIDEO]);
        bool audDiscontinuity = (mAudioFormat != FORMAT_INVALID && mProcessingDiscontinuity[eMEDIATYPE_AUDIO]);
        bool auxDiscontinuity = (mAuxFormat != FORMAT_INVALID && mProcessingDiscontinuity[eMEDIATYPE_AUX_AUDIO]);
 
        return (vidDiscontinuity || auxDiscontinuity || auxDiscontinuity);
}
 
/**
 * @brief Reset discontinuity flag for all tracks
 */
void PrivateInstanceAAMP::ResetDiscontinuityInTracks()
{
        mProcessingDiscontinuity[eMEDIATYPE_VIDEO] = false;
        mProcessingDiscontinuity[eMEDIATYPE_AUDIO] = false;
        mProcessingDiscontinuity[eMEDIATYPE_AUX_AUDIO] = false;
}
 
/**
 *  @brief set preferred Audio Language properties like language, rendition, type and codec
 */
void PrivateInstanceAAMP::SetPreferredLanguages(const char *languageList, const char *preferredRendition, const char *preferredType, const char *codecList, const char *labelList )
{
 
        /**< First argment is Json data then parse it and and assign the variables properly*/
        AampJsonObject* jsObject = NULL;
        bool isJson = false;
        bool isRetuneNeeded = false;
        bool accessibilityPresent = false;
        try
        {       
                jsObject = new AampJsonObject(languageList);
                if (jsObject)
                {
                        AAMPLOG_INFO("Preferred Language Properties received as json : %s", languageList);
                        isJson = true;
                }
        }
        catch(const std::exception& e)
        {
                /**<Nothing to do exclude it*/
        }
 
        if (isJson)
        {
                std::vector<std::string> inputLanguagesList;
                std::string inputLanguagesString;
                
                /** Get language Properties*/
                if (jsObject->isArray("languages"))
                {
                        if (jsObject->get("languages", inputLanguagesList))
                        {
                                for (auto preferredLanguage : inputLanguagesList)
                                {
                                        if (!inputLanguagesString.empty())
                                        {
                                                inputLanguagesString += ",";
                                        }
                                        inputLanguagesString += preferredLanguage; 
                                }
                        }
                }
                else if (jsObject->isString("languages"))
                {
                        if (jsObject->get("languages", inputLanguagesString))
                        {
                                inputLanguagesList.push_back(inputLanguagesString);
                        }
                }
                else
                {
                        AAMPLOG_ERR("Preferred Audio Language Field Only support String or String Array");
                }
 
                AAMPLOG_INFO("Number of preferred languages received: %lu", inputLanguagesList.size());
                AAMPLOG_INFO("Preferred language string received: %s", inputLanguagesString.c_str());
 
                std::string inputLabelsString;
                /** Get Label Properties*/
                if (jsObject->isString("label"))
                {
                        if (jsObject->get("label", inputLabelsString))
                        {
                                AAMPLOG_INFO("Preferred Label string: %s", inputLabelsString.c_str());  
                        }
                }
 
                string inputRenditionString;
 
                /** Get rendition or role Properties*/
                if (jsObject->isString("rendition"))
                {
                        if (jsObject->get("rendition", inputRenditionString))
                        {
                                AAMPLOG_INFO("Preferred rendition string: %s", inputRenditionString.c_str());   
                        }
                }
 
                Accessibility  inputAudioAccessibilityNode;
                /** Get accessibility Properties*/
                if (jsObject->isObject("accessibility"))
                {
                        AampJsonObject accessNode;
                        if (jsObject->get("accessibility", accessNode))
                        {
                                inputAudioAccessibilityNode = StreamAbstractionAAMP_MPD::getAccessibilityNode(accessNode);
                                if (!inputAudioAccessibilityNode.getSchemeId().empty())
                                {
                                        AAMPLOG_INFO("Preferred accessibility SchemeId: %s", inputAudioAccessibilityNode.getSchemeId().c_str());        
                                        if (inputAudioAccessibilityNode.getTypeName() == "string_value")
                                        {
                                                AAMPLOG_INFO("Preferred accessibility Value Type %s and Value: %s", inputAudioAccessibilityNode.getTypeName().c_str(), 
                                                        inputAudioAccessibilityNode.getStrValue().c_str());
                                        }
                                        else
                                        {
                                                AAMPLOG_INFO("Preferred accessibility Value Type %s and Value : %d", inputAudioAccessibilityNode.getTypeName().c_str(), 
                                                        inputAudioAccessibilityNode.getIntValue());
                                        }
                                }       
                        }
                        if(preferredAudioAccessibilityNode != inputAudioAccessibilityNode )
                        {
                                accessibilityPresent = true;
                        }
                }
 
                /**< Release json object **/
                delete jsObject;
                jsObject = NULL;
 
                if ((preferredAudioAccessibilityNode != inputAudioAccessibilityNode ) || (preferredRenditionString != inputRenditionString ) || 
                (preferredLabelsString != inputLabelsString) || (inputLanguagesList != preferredLanguagesList ))
                {
                        isRetuneNeeded = true;
                }
 
                /** Clear the cache **/
                preferredAudioAccessibilityNode.clear();
                preferredLabelsString.clear();
                preferredRenditionString.clear();
                preferredLanguagesString.clear();
                preferredLanguagesList.clear();
                
                /** Reload the new values **/
                preferredAudioAccessibilityNode = inputAudioAccessibilityNode;
                preferredRenditionString = inputRenditionString;
                preferredLabelsString = inputLabelsString;
                preferredLanguagesList = inputLanguagesList;
                preferredLanguagesString = inputLanguagesString;
 
                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_PreferredAudioRendition,preferredRenditionString);
                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_PreferredAudioLabel,preferredLabelsString);    
                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_PreferredAudioLanguage,preferredLanguagesString);
        }
        else
        {
                if((languageList && preferredLanguagesString != languageList) ||
                (preferredRendition && preferredRenditionString != preferredRendition) ||
                (preferredType && preferredTypeString != preferredType) ||
                (codecList && preferredCodecString != codecList) ||
                (labelList && preferredLabelsString != labelList)
                ) 
                {
                        isRetuneNeeded = true;
                        if(languageList != NULL)
                        {
                                preferredLanguagesString.clear();
                                preferredLanguagesList.clear();
                                preferredLanguagesString = std::string(languageList);
                                std::istringstream ss(preferredLanguagesString);
                                std::string lng;
                                while(std::getline(ss, lng, ','))
                                {
                                        preferredLanguagesList.push_back(lng);
                                        AAMPLOG_INFO("Parsed preferred lang: %s", lng.c_str());
                                }
 
                                preferredLanguagesString = std::string(languageList);
                                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_PreferredAudioLanguage,preferredLanguagesString);
                        }
 
                        AAMPLOG_INFO("Number of preferred languages: %lu", preferredLanguagesList.size());
                        
                        if(labelList != NULL)
                        {
                                preferredLabelsString.clear();
                                preferredLabelList.clear();
                                preferredLabelsString = std::string(labelList);
                                std::istringstream ss(preferredLabelsString);
                                std::string lab;
                                while(std::getline(ss, lab, ','))
                                {
                                        preferredLabelList.push_back(lab);
                                        AAMPLOG_INFO("Parsed preferred label: %s", lab.c_str());
                                }
 
                                preferredLabelsString = std::string(labelList);
                                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_PreferredAudioLabel,preferredLabelsString);
                                AAMPLOG_INFO("Number of preferred labels: %lu", preferredLabelList.size());
                        }
 
                        if( preferredRendition )
                        {
                                AAMPLOG_INFO("Setting rendition %s", preferredRendition);
                                preferredRenditionString = std::string(preferredRendition);
                                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_PreferredAudioRendition,preferredRenditionString);
                        }
                        else
                        {
                                preferredRenditionString.clear();
                        }
 
                        if( preferredType )
                        {
                                preferredTypeString = std::string(preferredType);
                                std::string delim = "_";
                                auto pos = preferredTypeString.find(delim);
                                auto end = preferredTypeString.length();
                                if (pos != std::string::npos)
                                {
                                        preferredTypeString =  preferredTypeString.substr(pos+1, end);
                                }
                                AAMPLOG_INFO("Setting accessibility type %s", preferredTypeString.c_str());
                                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING, eAAMPConfig_PreferredAudioType, preferredTypeString);
                        }
                        else
                        {
                                preferredTypeString.clear();
                        }
 
                        if(codecList != NULL)
                        {
                                preferredCodecString.clear();
                                preferredCodecList.clear();
                                preferredCodecString = std::string(codecList);
                                std::istringstream ss(preferredCodecString);
                                std::string codec;
                                while(std::getline(ss, codec, ','))
                                {
                                        preferredCodecList.push_back(codec);
                                        AAMPLOG_INFO("Parsed preferred codec: %s", codec.c_str());
                                }
                                preferredCodecString = std::string(codecList);
                                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_PreferredAudioCodec,preferredCodecString);
                        }
                        AAMPLOG_INFO("Number of preferred codecs: %lu", preferredCodecList.size());
                }
                else
                {
                        AAMPLOG_INFO("Discarding Retune set lanuage(s) (%s) , rendition (%s) and accessibility (%s) since already set",
                        languageList?languageList:"", preferredRendition?preferredRendition:"", preferredType?preferredType:"");
                }
        }
 
        PrivAAMPState state;
        GetState(state);
        if (state != eSTATE_IDLE && state != eSTATE_RELEASED && state != eSTATE_ERROR && isRetuneNeeded)
        { // active playback session; apply immediately
                if (mpStreamAbstractionAAMP)
                {
                        bool languagePresent = false;
                        bool renditionPresent = false;
                        bool accessibilityTypePresent = false;
                        bool codecPresent = false;
                        bool labelPresent = false;
                        int trackIndex = GetAudioTrack();
 
                        bool languageAvailabilityInManifest = false;
                        bool renditionAvailabilityInManifest = false;
                        bool accessibilityAvailabilityInManifest = false;
                        bool labelAvailabilityInManifest = false;
                        std::string trackIndexStr;
 
                        if (trackIndex >= 0)
                        {
                                std::vector<AudioTrackInfo> trackInfo = mpStreamAbstractionAAMP->GetAvailableAudioTracks();
                                char *currentPrefLanguage = const_cast<char*>(trackInfo[trackIndex].language.c_str());
                                char *currentPrefRendition = const_cast<char*>(trackInfo[trackIndex].rendition.c_str());
                                char *currentPrefAccessibility = const_cast<char*>(trackInfo[trackIndex].accessibilityType.c_str());
                                char *currentPrefCodec = const_cast<char*>(trackInfo[trackIndex].codec.c_str());
                                char *currentPrefLabel = const_cast<char*>(trackInfo[trackIndex].label.c_str());
 
                                // Logic to check whether the given language is present in the available tracks,
                                // if available, it should not match with current preferredLanguagesString, then call tune to reflect the language change.
                                // if not available, then avoid calling tune.
                                if(preferredLanguagesList.size() > 0)
                                {
                                        std::string firstLanguage = preferredLanguagesList.at(0);
                                        auto language = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [firstLanguage, currentPrefLanguage](AudioTrackInfo& temp)
                                                                { return ((temp.language == firstLanguage) && (temp.language != currentPrefLanguage)); });
                                        languagePresent = (language != end(trackInfo) || (preferredLanguagesList.size() > 1)); /* If multiple value of language is present then retune */
                                        auto languageAvailable = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [firstLanguage, currentPrefLanguage](AudioTrackInfo& temp)
                                                                { return ((temp.language == firstLanguage) && (temp.language != currentPrefLanguage) && (temp.isAvailable)); });
                                        languageAvailabilityInManifest = (languageAvailable != end(trackInfo) && languageAvailable->isAvailable);
                                        if(languagePresent && (language != end(trackInfo)))
                                        {
                                                trackIndexStr = language->index;
                                        }
                                }
 
                                // Logic to check whether the given label is present in the available tracks,
                                // if available, it should not match with current preferredLabelsString, then call retune to reflect the language change.
                                // if not available, then avoid calling tune. Call retune if multiple labels is present
                                if(!preferredLabelsString.empty())
                                {
                                        std::string curLabel = preferredLabelsString;
                                        auto label = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [curLabel, currentPrefLabel](AudioTrackInfo& temp)
                                                                { return ((temp.label == curLabel) && (temp.label != currentPrefLabel)); });
                                        labelPresent = (label != end(trackInfo) || (preferredLabelList.size() > 1)); /* If multiple value of label is present then retune */
                                        auto labelAvailable = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [curLabel, currentPrefLabel](AudioTrackInfo& temp)
                                                                { return ((temp.label == curLabel) && (temp.label != currentPrefLabel) && (temp.isAvailable)); });
                                        labelAvailabilityInManifest = ((labelAvailable != end(trackInfo) ) && labelAvailable->isAvailable);
 
                                }
 
                                
                                // Logic to check whether the given rendition is present in the available tracks,
                                // if available, it should not match with current preferredRenditionString, then call tune to reflect the rendition change.
                                // if not available, then avoid calling tune.
                                if(!preferredRenditionString.empty())
                                {
                                        std::string curRendition = preferredRenditionString;
                                        auto rendition = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [curRendition, currentPrefRendition](AudioTrackInfo& temp)
                                                                { return ((temp.rendition == curRendition) && (temp.rendition != currentPrefRendition)); });
                                        renditionPresent = (rendition != end(trackInfo));
                                        auto renditionAvailable = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [curRendition, currentPrefRendition](AudioTrackInfo& temp)
                                                                { return ((temp.rendition == curRendition) && (temp.rendition != currentPrefRendition) && (temp.isAvailable)); });
                                        renditionAvailabilityInManifest = ((renditionAvailable != end(trackInfo)) && renditionAvailable->isAvailable);
                                }
 
                                // Logic to check whether the given accessibility is present in the available tracks,
                                // if available, it should not match with current preferredTypeString, then call tune to reflect the accessibility change.
                                // if not available, then avoid calling tune.
                                if(!preferredTypeString.empty())
                                {
                                        std:;string curType = preferredTypeString;
                                        auto accessType = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [curType, currentPrefAccessibility](AudioTrackInfo& temp)
                                                                { return ((temp.accessibilityType == curType) && (temp.accessibilityType != currentPrefAccessibility)); });
                                        accessibilityTypePresent = (accessType != end(trackInfo));
                                        auto accessTypeAvailable = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [curType, currentPrefAccessibility](AudioTrackInfo& temp)
                                                                { return ((temp.accessibilityType == curType) && (temp.accessibilityType != currentPrefAccessibility) && (temp.isAvailable)); });
                                        accessibilityAvailabilityInManifest = ((accessTypeAvailable != end(trackInfo)) && accessTypeAvailable->isAvailable);
                                }
 
                                // Logic to check whether the given codec is present in the available tracks,
                                // if available, it should not match with current preferred codec, then call tune to reflect the codec change.
                                // if not available, then avoid calling tune.
                                if(preferredCodecList.size() > 0)
                                {
                                        std::string firstCodec = preferredCodecList.at(0);
                                        auto codec = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [firstCodec, currentPrefCodec](AudioTrackInfo& temp)
                                                                { return ((temp.codec == firstCodec) && (temp.codec != currentPrefCodec) && (temp.isAvailable)); });
                                        codecPresent = (codec != end(trackInfo) || (preferredCodecList.size() > 1) ); /* If multiple value of codec is present then retune */
                                }
                        }
 
                        bool clearPreference = false;
                        if(isRetuneNeeded && preferredCodecList.size() == 0 && preferredTypeString.empty() && preferredRenditionString.empty() \
                                && preferredLabelsString.empty() && preferredLanguagesList.size() == 0)
                        {
                                /** Previouse preference set and API called to clear all preferences; so retune to make effect **/
                                AAMPLOG_INFO("API to clear all preferences; retune to make it affect");
                                clearPreference = true;
                        }
 
                        if((mMediaFormat == eMEDIAFORMAT_OTA) || (mMediaFormat == eMEDIAFORMAT_RMF))
                        {
                                mpStreamAbstractionAAMP->SetPreferredAudioLanguages();
                        }
                        else if((mMediaFormat == eMEDIAFORMAT_HDMI) || (mMediaFormat == eMEDIAFORMAT_COMPOSITE))
                        {
                                /*Avoid retuning in case of HEMIIN and COMPOSITE IN*/
                        }
                        else if (languagePresent || renditionPresent || accessibilityTypePresent || codecPresent || labelPresent || accessibilityPresent || clearPreference) // call the tune only if there is a change in the language, rendition or accessibility.
                        {
                                if(!ISCONFIGSET_PRIV(eAAMPConfig_ChangeTrackWithoutRetune))
                                {
                                        discardEnteringLiveEvt = true;
 
                                        seek_pos_seconds = GetPositionSeconds();
                                        mOffsetFromTunetimeForSAPWorkaround = (double)(aamp_GetCurrentTimeMS() / 1000) - mLiveOffset;
                                        mLanguageChangeInProgress = true;
                                        AcquireStreamLock();
                                        TeardownStream(false);
                                        if(IsTSBSupported() &&
                                         ((languagePresent && !languageAvailabilityInManifest) ||
                                         (renditionPresent && !renditionAvailabilityInManifest) ||
                                         (accessibilityTypePresent && !accessibilityAvailabilityInManifest) ||
                                         (labelPresent && !labelAvailabilityInManifest)))
                                        {
                                                ReloadTSB();
                                        }
                                        TuneHelper(eTUNETYPE_SEEK);
                                        discardEnteringLiveEvt = false;
                                        ReleaseStreamLock();
                                }
                                else if(!trackIndexStr.empty())
                                {
                                        mpStreamAbstractionAAMP->ChangeMuxedAudioTrackIndex(trackIndexStr);
                                }
                        }
                }
        }
}
 
/**
 *  @brief Set Preferred Text Language
 */
void PrivateInstanceAAMP::SetPreferredTextLanguages(const char *param )
{
 
        /**< First argment is Json data then parse it and and assign the variables properly*/
        AampJsonObject* jsObject = NULL;
        bool isJson = false;
        bool isRetuneNeeded = false;
        bool accessibilityPresent = false;
        try
        {
                jsObject = new AampJsonObject(param);
                if (jsObject)
                {
                        AAMPLOG_INFO("Preferred Text Language Properties received as json : %s", param);
                        isJson = true;
                }
        }
        catch(const std::exception& e)
        {
                /**<Nothing to do exclude it*/
        }
 
        if (isJson)
        {
                std::vector<std::string> inputTextLanguagesList;
                std::string inputTextLanguagesString;
                
                /** Get language Properties*/
                if(jsObject->isArray("languages"))
                { // if starting with array, join to string
                        if (jsObject->get("languages", inputTextLanguagesList))
                        {
                                for (auto preferredLanguage : inputTextLanguagesList)
                                {
                                        if (!inputTextLanguagesString.empty())
                                        {
                                                inputTextLanguagesString += "," ;
                                        }
                                        inputTextLanguagesString += preferredLanguage;  
                                }
                        }
                }
                else if (jsObject->isString("languages"))
                { // if starting with string, create simple array
                        if (jsObject->get("languages", inputTextLanguagesString))
                        {
                                inputTextLanguagesList.push_back(inputTextLanguagesString);
                        }
                }
                else
                {
                        AAMPLOG_ERR("Preferred Text Language Field Only support String or String Array");
                }
 
                AAMPLOG_INFO("Number of preferred Text languages: %lu", inputTextLanguagesList.size());
                AAMPLOG_INFO("Preferred Text languages string: %s", inputTextLanguagesString.c_str());
 
                std::string inputTextRenditionString;
                /** Get rendition or role Properties*/
                if (jsObject->isString("rendition"))
                {
                        if (jsObject->get("rendition", inputTextRenditionString))
                        {
                                AAMPLOG_INFO("Preferred text rendition string: %s", inputTextRenditionString.c_str());  
                        }
                }
 
                std::string inputTextLabelString;
                /** Get label Properties*/
                if (jsObject->isString("label"))
                {
                        if (jsObject->get("label", inputTextLabelString))
                        {
                                AAMPLOG_INFO("Preferred text label string: %s", inputTextLabelString.c_str());  
                        }
                }
 
                std::string inputTextTypeString;
                /** Get accessibility type Properties*/
                if (jsObject->isString("accessibilityType"))
                {
                        if (jsObject->get("accessibilityType", inputTextTypeString))
                        {
                                AAMPLOG_INFO("Preferred text type string: %s", inputTextTypeString.c_str());    
                        }
                }
 
                Accessibility  inputTextAccessibilityNode;
                /** Get accessibility Properties*/
                if (jsObject->isObject("accessibility"))
                {
                        AampJsonObject accessNode;
                        if (jsObject->get("accessibility", accessNode))
                        {
                                inputTextAccessibilityNode = StreamAbstractionAAMP_MPD::getAccessibilityNode(accessNode);
                                if (!inputTextAccessibilityNode.getSchemeId().empty())
                                {
                                        AAMPLOG_INFO("Preferred accessibility SchemeId: %s", inputTextAccessibilityNode.getSchemeId().c_str()); 
                                        if (inputTextAccessibilityNode.getTypeName() == "string_value")
                                        {
                                                AAMPLOG_INFO("Preferred accessibility Value Type %s and Value: %s", inputTextAccessibilityNode.getTypeName().c_str(), 
                                                        inputTextAccessibilityNode.getStrValue().c_str());
                                        }
                                        else
                                        {
                                                AAMPLOG_INFO("Preferred accessibility Value Type %s and Value : %d", inputTextAccessibilityNode.getTypeName().c_str(), 
                                                        inputTextAccessibilityNode.getIntValue());
                                        }
                                }
                                if(inputTextAccessibilityNode != preferredTextAccessibilityNode)
                                {
                                        accessibilityPresent = true;
                                }
                        }       
                }
                
                /**< Release json object **/
                delete jsObject;
                jsObject = NULL;
 
                if((inputTextLanguagesList != preferredTextLanguagesList) || (inputTextRenditionString != preferredTextRenditionString) || 
                (inputTextAccessibilityNode != preferredTextAccessibilityNode))
                {
                        isRetuneNeeded = true;
                }
 
                preferredTextLanguagesList.clear();
                preferredTextLanguagesString.clear();
                preferredTextRenditionString.clear();
                preferredTextAccessibilityNode.clear();
                preferredTextLabelString.clear();
 
                preferredTextLanguagesList = inputTextLanguagesList;
                preferredTextLanguagesString = inputTextLanguagesString;
                preferredTextRenditionString = inputTextRenditionString;
                preferredTextAccessibilityNode = inputTextAccessibilityNode;
                preferredTextLabelString = inputTextLabelString;
                preferredTextTypeString = inputTextTypeString;
                
                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_PreferredTextLanguage,preferredTextLanguagesString);
                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_PreferredTextRendition,preferredTextRenditionString);
                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_PreferredTextLabel,preferredTextLabelString);
                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING,eAAMPConfig_PreferredTextType,preferredTextTypeString);
        }
        else if( param )
        {
                AAMPLOG_INFO("Setting Text Languages  %s", param);
                std::string inputTextLanguagesString;
                inputTextLanguagesString = std::string(param);
                
                if (inputTextLanguagesString != preferredTextLanguagesString)
                {
                        isRetuneNeeded = true;
                }
                preferredTextLanguagesList.clear();
                preferredTextLanguagesList.push_back(inputTextLanguagesString);
                preferredTextLanguagesString = inputTextLanguagesString;
                SETCONFIGVALUE_PRIV(AAMP_APPLICATION_SETTING, eAAMPConfig_PreferredTextLanguage, preferredTextLanguagesString);
        }
        else
        {
                AAMPLOG_INFO("No valid Parameter Recieved");
                return;
        }
 
        PrivAAMPState state;
        GetState(state);
        if (state != eSTATE_IDLE && state != eSTATE_RELEASED && state != eSTATE_ERROR && isRetuneNeeded )
        { // active playback session; apply immediately
                if (mpStreamAbstractionAAMP)
                {
                        bool languagePresent = false;
                        bool renditionPresent = false;
                        bool accessibilityTypePresent = false;
                        bool codecPresent = false;
                        bool labelPresent = false;
                        int trackIndex = GetTextTrack();
                        bool languageAvailabilityInManifest = false;
                        bool renditionAvailabilityInManifest = false;
                        bool accessibilityAvailabilityInManifest = false;
                        bool labelAvailabilityInManifest = false;
                        bool trackNotEnabled = false;
                        
                        if (trackIndex >= 0)
                        {
                                std::vector<TextTrackInfo> trackInfo = mpStreamAbstractionAAMP->GetAvailableTextTracks();
                                char *currentPrefLanguage = const_cast<char*>(trackInfo[trackIndex].language.c_str());
                                char *currentPrefRendition = const_cast<char*>(trackInfo[trackIndex].rendition.c_str());
 
                                // Logic to check whether the given language is present in the available tracks,
                                // if available, it should not match with current preferredLanguagesString, then call tune to reflect the language change.
                                // if not available, then avoid calling tune.
                                if(preferredTextLanguagesList.size() > 0)
                                {
                                        std::string firstLanguage = preferredTextLanguagesList.at(0);
                                        auto language = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [firstLanguage, currentPrefLanguage](TextTrackInfo& temp)
                                                                { return ((temp.language == firstLanguage) && (temp.language != currentPrefLanguage)); });
                                        languagePresent = (language != end(trackInfo) || (preferredTextLanguagesList.size() > 1)); /* If multiple value of language is present then retune */
                                        auto languageAvailable = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [firstLanguage, currentPrefLanguage](TextTrackInfo& temp)
                                                                { return ((temp.language == firstLanguage) && (temp.language != currentPrefLanguage) && (temp.isAvailable)); });
                                        languageAvailabilityInManifest = (languageAvailable != end(trackInfo) && languageAvailable->isAvailable);
                                }
 
                                // Logic to check whether the given rendition is present in the available tracks,
                                // if available, it should not match with current preferredTextRenditionString, then call tune to reflect the rendition change.
                                // if not available, then avoid calling tune.
                                if(!preferredTextRenditionString.empty())
                                {
                                        std::string curRendition = preferredTextRenditionString;
                                        auto rendition = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [curRendition, currentPrefRendition](TextTrackInfo& temp)
                                                                { return ((temp.rendition == curRendition) && (temp.rendition != currentPrefRendition)); });
                                        renditionPresent = (rendition != end(trackInfo));
                                        auto renditionAvailable = std::find_if(trackInfo.begin(), trackInfo.end(),
                                                                [curRendition, currentPrefRendition](TextTrackInfo& temp)
                                                                { return ((temp.rendition == curRendition) && (temp.rendition != currentPrefRendition) && (temp.isAvailable)); });
                                        renditionAvailabilityInManifest = ((renditionAvailable != end(trackInfo)) && renditionAvailable->isAvailable);
                                }
                        }
                        else
                        {
                                trackNotEnabled = true;
                        }
 
                        if((mMediaFormat == eMEDIAFORMAT_HDMI) || (mMediaFormat == eMEDIAFORMAT_COMPOSITE) || (mMediaFormat == eMEDIAFORMAT_OTA) || \
                                (mMediaFormat == eMEDIAFORMAT_RMF))
                        {
                                /**< Avoid retuning in case of HEMIIN and COMPOSITE IN*/
                        }
                        else if (languagePresent || renditionPresent || accessibilityPresent || trackNotEnabled) /**< call the tune only if there is a change in the language, rendition or accessibility.*/
                        {
                                discardEnteringLiveEvt = true;
                                seek_pos_seconds = GetPositionSeconds();
                                mOffsetFromTunetimeForSAPWorkaround = (double)(aamp_GetCurrentTimeMS() / 1000) - mLiveOffset;
                                mLanguageChangeInProgress = true;
                                AcquireStreamLock();
                                TeardownStream(false);
                                if(IsTSBSupported() &&
                                 ((languagePresent && !languageAvailabilityInManifest) ||
                                 (renditionPresent && !renditionAvailabilityInManifest) ||
                                 (accessibilityTypePresent && !accessibilityAvailabilityInManifest) ||
                                 (labelPresent && !labelAvailabilityInManifest)))
                                {
                                        ReloadTSB();
                                }
 
                                TuneHelper(eTUNETYPE_SEEK);
                                discardEnteringLiveEvt = false;
                                ReleaseStreamLock();
                        }
                }
        }
}
 
#define WV_KID_WORKAROUND "SkyStoreDE="
 
/**
 * @brief get the SkyDE Store workaround
 */
bool PrivateInstanceAAMP::IsWideVineKIDWorkaround(std::string url)
{
        bool enable = false;
        int pos = url.find(WV_KID_WORKAROUND);
        if (pos != string::npos){
                pos = pos + strlen(WV_KID_WORKAROUND);
                AAMPLOG_INFO("URL found WideVine KID Workaround at %d key = %c",
            pos, url.at(pos));
                enable = (url.at(pos) == '1');
        }
 
        return enable;
}
 
//#define ENABLE_DUMP 1 //uncomment this to enable dumping of PSSH Data
 
/**
 * @brief Replace KeyID from PsshData
 */ 
unsigned char* PrivateInstanceAAMP::ReplaceKeyIDPsshData(const unsigned char *InputData, const size_t InputDataLength,  size_t & OutputDataLength)
{
        unsigned char *OutpuData = NULL;
        unsigned int WIDEVINE_PSSH_KEYID_OFFSET = 36u;
        unsigned int WIDEVINE_PSSH_DATA_SIZE = 60u;
        unsigned int CK_PSSH_KEYID_OFFSET = 32u;
        unsigned int COMMON_KEYID_SIZE = 16u;
        unsigned char WVSamplePSSH[] = {
                0x00, 0x00, 0x00, 0x3c, 
                0x70, 0x73, 0x73, 0x68, 
                0x00, 0x00, 0x00, 0x00, 
                0xed, 0xef, 0x8b, 0xa9, 0x79, 0xd6, 0x4a, 0xce, 
                0xa3, 0xc8, 0x27, 0xdc, 0xd5, 0x1d, 0x21, 0xed, 
                0x00, 0x00, 0x00, 0x1c, 0x08, 0x01, 0x12, 0x10,  
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //dummy KeyId (16 byte)
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //dummy KeyId (16 byte)
                0x22, 0x06, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x37
        };
        if (InputData){
                AAMPLOG_INFO("Converting system UUID of PSSH data size (%zu)", InputDataLength);
#ifdef ENABLE_DUMP
                AAMPLOG_INFO("PSSH Data (%d) Before Modification : ", InputDataLength);
                DumpBlob(InputData, InputDataLength);
#endif
 
                /** Replace KeyID of WV PSSH Data with Key ID of CK PSSH Data **/
                int iWVpssh = WIDEVINE_PSSH_KEYID_OFFSET; 
                int CKPssh = CK_PSSH_KEYID_OFFSET;
                int size = 0;
                if (CK_PSSH_KEYID_OFFSET+COMMON_KEYID_SIZE <=  InputDataLength){
                        for (; size < COMMON_KEYID_SIZE; ++size, ++iWVpssh, ++CKPssh  ){
                                /** Transfer KeyID from CK PSSH data to WV PSSH Data **/
                                WVSamplePSSH[iWVpssh] = InputData[CKPssh];
                        }
 
                        /** Allocate WV PSSH Data memory and transfer local data **/
                        OutpuData = (unsigned char *)malloc(sizeof(WVSamplePSSH));
                        if (OutpuData){
                                memcpy(OutpuData, WVSamplePSSH, sizeof(WVSamplePSSH));
                                OutputDataLength = sizeof(WVSamplePSSH);
#ifdef ENABLE_DUMP
                                AAMPLOG_INFO("PSSH Data (%d) after Modification : ", OutputDataLength);
                                DumpBlob(OutpuData, OutputDataLength);
#endif
                                return OutpuData;
 
                        }else{
                                AAMPLOG_ERR("PSSH Data Memory allocation failed ");
                        }
                }else{
                        //Invalid PSSH data
                        AAMPLOG_ERR("Invalid Clear Key PSSH data ");
                }
        }else{
                //Inalid argument - PSSH Data
                AAMPLOG_ERR("Invalid Argument of PSSH data ");
        }
        return NULL;
}
 
/**
 * @brief Check if segment starts with an ID3 section
 */
bool PrivateInstanceAAMP::hasId3Header(const uint8_t* data, uint32_t length)
{
        if (length >= 3)
        {
                /* Check file identifier ("ID3" = ID3v2) and major revision matches (>= ID3v2.2.x). */
                if (*data++ == 'I' && *data++ == 'D' && *data++ == '3' && *data++ >= 2)
                {
                        return true;
                }
        }
        return false;
}
 
/**
 * @brief Process the ID3 metadata from segment
 */
void PrivateInstanceAAMP::ProcessID3Metadata(char *segment, size_t size, MediaType type, uint64_t timeStampOffset)
{
        // Logic for ID3 metadata
        if(segment && mEventManager->IsEventListenerAvailable(AAMP_EVENT_ID3_METADATA))
        {
                IsoBmffBuffer buffer(mLogObj);
                buffer.setBuffer((uint8_t *)segment, size);
                buffer.parseBuffer();
                if(!buffer.isInitSegment())
                {
                        uint8_t* message = nullptr;
                        uint32_t messageLen = 0;
                        uint8_t* schemeIDUri = nullptr;
                        uint8_t* value = nullptr;
                        uint64_t presTime = 0;
                        uint32_t timeScale = 0;
                        uint32_t eventDuration = 0;
                        uint32_t id = 0;
                        if(buffer.getEMSGData(message, messageLen, schemeIDUri, value, presTime, timeScale, eventDuration, id))
                        {
                                if(message && messageLen > 0 && hasId3Header(message, messageLen))
                                {
                                        AAMPLOG_TRACE("PrivateInstanceAAMP: Found ID3 metadata[%d]", type);
                                        if(mMediaFormat == eMEDIAFORMAT_DASH)
                                        {
                                                ReportID3Metadata(type, message, messageLen, (char*)(schemeIDUri), (char*)(value), presTime, id, eventDuration, timeScale, GetMediaStreamContext(type)->timeStampOffset);
                                        }else
                                        {
                                                ReportID3Metadata(type, message, messageLen, (char*)(schemeIDUri), (char*)(value), presTime, id, eventDuration, timeScale);
                                        }
                                }
                        }
                }
        }
}
 
/**
 * @brief Report ID3 metadata events
 */
void PrivateInstanceAAMP::ReportID3Metadata(MediaType mediaType, const uint8_t* ptr, uint32_t len, const char* schemeIdURI, const char* id3Value, uint64_t presTime, uint32_t id3ID, uint32_t eventDur, uint32_t tScale, uint64_t tStampOffset)
{
        FlushLastId3Data(mediaType);
        Id3CallbackData* id3Metadata = new Id3CallbackData(this, static_cast<const uint8_t*>(ptr), len, static_cast<const char*>(schemeIdURI), static_cast<const char*>(id3Value), presTime, id3ID, eventDur, tScale, tStampOffset);
        lastId3Data[mediaType] = (uint8_t*)aamp_Malloc(len);
        if (lastId3Data[mediaType])
        {
                lastId3DataLen[mediaType] = len;
                memcpy(lastId3Data[mediaType], ptr, len);
        }
 
        SendId3MetadataEvent(id3Metadata);
        SAFE_DELETE(id3Metadata);
}
 
/**
 * @brief Flush last saved ID3 metadata
 */ 
void PrivateInstanceAAMP::FlushLastId3Data(MediaType mediaType)
{
        if(lastId3Data[mediaType])
        {
                lastId3DataLen[mediaType] = 0;
                aamp_Free((void *)lastId3Data[mediaType]);
                lastId3Data[mediaType] = NULL;
        }
}
 
/**
 * @brief GetPauseOnFirstVideoFrameDisplay
 */
bool PrivateInstanceAAMP::GetPauseOnFirstVideoFrameDisp(void)
{
    return mPauseOnFirstVideoFrameDisp;
}
 
/** 
 * @brief Sets  Low Latency Service Data
 */
void PrivateInstanceAAMP::SetLLDashServiceData(AampLLDashServiceData &stAampLLDashServiceData)
{
    this->mAampLLDashServiceData = stAampLLDashServiceData;
}
 
/**
 * @brief Gets Low Latency Service Data
 */
AampLLDashServiceData*  PrivateInstanceAAMP::GetLLDashServiceData(void)
{
    return &this->mAampLLDashServiceData;
}
 
 
/**
 * @brief Sets Low Video TimeScale
 */
void PrivateInstanceAAMP::SetVidTimeScale(uint32_t vidTimeScale)
{
    this->vidTimeScale = vidTimeScale;
}
 
/**
 * @brief Gets Video TimeScale
 */
uint32_t  PrivateInstanceAAMP::GetVidTimeScale(void)
{
    return vidTimeScale;
}
 
/**
 * @brief Sets Low Audio TimeScale
 */
void PrivateInstanceAAMP::SetAudTimeScale(uint32_t audTimeScale)
{
    this->audTimeScale = audTimeScale;
}
 
/**
 * @brief Gets Audio TimeScale
 */
uint32_t  PrivateInstanceAAMP::GetAudTimeScale(void)
{
    return audTimeScale;
}
/**
 * @brief Sets Speed Cache
 */
void PrivateInstanceAAMP::SetLLDashSpeedCache(struct SpeedCache &speedCache)
{
    this->speedCache = speedCache;
}
 
/**
 * @brief Gets Speed Cache
 */
struct SpeedCache* PrivateInstanceAAMP::GetLLDashSpeedCache()
{
    return &speedCache;
}
 
bool PrivateInstanceAAMP::GetLiveOffsetAppRequest()
{
    return mLiveOffsetAppRequest;
}
 
/**
 * @brief set LiveOffset Request flag Status
 */
void PrivateInstanceAAMP::SetLiveOffsetAppRequest(bool LiveOffsetAppRequest)
{
    this->mLiveOffsetAppRequest = LiveOffsetAppRequest;
}
/**
 *  @brief Get Low Latency Service Configuration Status
 */
bool PrivateInstanceAAMP::GetLowLatencyServiceConfigured()
{
    return bLowLatencyServiceConfigured;
}
 
/**
 *  @brief Set Low Latency Service Configuration Status
 */
void PrivateInstanceAAMP::SetLowLatencyServiceConfigured(bool bConfig)
{
    bLowLatencyServiceConfigured = bConfig;
}
 
/**
 *  @brief Get Utc Time
 */
time_t PrivateInstanceAAMP::GetUtcTime()
{
    return mTime;
}
 
/**
 *  @brief Set Utc Time
 */
void PrivateInstanceAAMP::SetUtcTime(time_t time)
{
    this->mTime = time;
}
 
/**
 *  @brief Get Current Latency
 */
long PrivateInstanceAAMP::GetCurrentLatency()
{
    return mCurrentLatency;
}
 
/**
 * @brief Set Current Latency
 */
void PrivateInstanceAAMP::SetCurrentLatency(long currentLatency)
{
    this->mCurrentLatency = currentLatency;
}
 
/**
 *     @brief Get Media Stream Context
 */
MediaStreamContext* PrivateInstanceAAMP::GetMediaStreamContext(MediaType type)
{
    if(mpStreamAbstractionAAMP &&
    (type == eMEDIATYPE_VIDEO ||
     type == eMEDIATYPE_AUDIO ||
     type == eMEDIATYPE_SUBTITLE ||
     type == eMEDIATYPE_AUX_AUDIO))
    {
        MediaStreamContext* context = (MediaStreamContext*)mpStreamAbstractionAAMP->GetMediaTrack((TrackType)type);
        return context;
    }
    return NULL;
}
 
/**
 *  @brief GetPeriodDurationTimeValue
 */
double PrivateInstanceAAMP::GetPeriodDurationTimeValue(void)
{
        return mNextPeriodDuration;
}
 
/**
 *  @brief GetPeriodStartTimeValue
 */
double PrivateInstanceAAMP::GetPeriodStartTimeValue(void)
{
        return mNextPeriodStartTime;
}
 
/**
 *  @brief GetPeriodScaledPtoStartTime
 */
double PrivateInstanceAAMP::GetPeriodScaledPtoStartTime(void)
{
       return mNextPeriodScaledPtoStartTime;
}
 
/**
 *  @brief Get playback stats for the session so far
 */
std::string PrivateInstanceAAMP::GetPlaybackStats()
{
        std::string strVideoStatsJson;
        long liveLatency = 0;
        //Update liveLatency only when playback is active and live
        if(mpStreamAbstractionAAMP && IsLive())
                liveLatency = mpStreamAbstractionAAMP->GetBufferedVideoDurationSec() * 1000.0;
 
        if(mVideoEnd)
        {
                mVideoEnd->setPlaybackMode(mPlaybackMode);
                mVideoEnd->setLiveLatency(liveLatency);
                mVideoEnd->SetDisplayResolution(mDisplayWidth,mDisplayHeight);
                //Update VideoEnd Data
                if(mTimeAtTopProfile > 0)
                {
                        // Losing milisecons of data in conversion from double to long
                        mVideoEnd->SetTimeAtTopProfile(mTimeAtTopProfile);
                        mVideoEnd->SetTimeToTopProfile(mTimeToTopProfile);
                }
                mVideoEnd->SetTotalDuration(mPlaybackDuration);
                char * videoStatsPtr = mVideoEnd->ToJsonString(nullptr, true);
                if(videoStatsPtr)
                {
                        strVideoStatsJson = videoStatsPtr;
                        free(videoStatsPtr);
                }
        }
        else
        {
                AAMPLOG_ERR("GetPlaybackStats failed, mVideoEnd is NULL");
        }
        
        if(!strVideoStatsJson.empty())
        {
                AAMPLOG_INFO("Playback stats json:%s", strVideoStatsJson.c_str());
        }
        else
        {
                AAMPLOG_ERR("Failed to retrieve playback stats (video stats returned as empty from aamp metrics)");
        }
        return strVideoStatsJson;
}
 
/**
* @brief LoadFogConfig - Load needed player Config to Fog
*/
long PrivateInstanceAAMP::LoadFogConfig()
{
        std::string jsonStr;
        AampJsonObject jsondata;
        double tmpVar = 0;
        long tmpLongVar = 0;
        int maxdownload = 0;
 
        // langCodePreference
        jsondata.add("langCodePreference", (int) GetLangCodePreference());
 
        // networkTimeout value in sec and convert into MS
        GETCONFIGVALUE_PRIV(eAAMPConfig_NetworkTimeout,tmpVar);
        jsondata.add("downloadTimeoutMS", (long)CONVERT_SEC_TO_MS(tmpVar));
        
        tmpVar = 0;
        // manifestTimeout value in sec and convert into MS
        GETCONFIGVALUE_PRIV(eAAMPConfig_ManifestTimeout,tmpVar);
        jsondata.add("manifestTimeoutMS", (long)CONVERT_SEC_TO_MS(tmpVar));
 
        tmpLongVar = 0;
        //downloadStallTimeout in sec
        GETCONFIGVALUE_PRIV(eAAMPConfig_CurlStallTimeout,tmpLongVar);
        jsondata.add("downloadStallTimeout", tmpLongVar);
 
        tmpLongVar = 0;
        //downloadStartTimeout sec
        GETCONFIGVALUE_PRIV(eAAMPConfig_CurlDownloadStartTimeout,tmpLongVar);
        jsondata.add("downloadStartTimeout", tmpLongVar);
 
        tmpLongVar = 0;
        //downloadStartTimeout sec
        GETCONFIGVALUE_PRIV(eAAMPConfig_CurlDownloadLowBWTimeout,tmpLongVar);
        jsondata.add("downloadLowBWTimeout", tmpLongVar);
 
        //maxConcurrentDownloads
        GETCONFIGVALUE_PRIV(eAAMPConfig_FogMaxConcurrentDownloads, maxdownload);
        jsondata.add("maxConcurrentDownloads", (long)(maxdownload));
 
        //disableEC3
        jsondata.add("disableEC3", ISCONFIGSET_PRIV(eAAMPConfig_DisableEC3));
 
        //disableATMOS
        jsondata.add("disableATMOS", ISCONFIGSET_PRIV(eAAMPConfig_DisableATMOS));
 
        //disableAC4
        jsondata.add("disableAC4", ISCONFIGSET_PRIV(eAAMPConfig_DisableAC4));
 
        //persistLowNetworkBandwidth
        jsondata.add("persistLowNetworkBandwidth", ISCONFIGSET_PRIV(eAAMPConfig_PersistLowNetworkBandwidth));
        
        //disableAC3
        jsondata.add("disableAC3", ISCONFIGSET_PRIV(eAAMPConfig_DisableAC3));
        
        //persistHighNetworkBandwidth
        jsondata.add("persistHighNetworkBandwidth", ISCONFIGSET_PRIV(eAAMPConfig_PersistHighNetworkBandwidth));
 
        //enableCMCD
        jsondata.add("enableCMCD", ISCONFIGSET_PRIV(eAAMPConfig_EnableCMCD));
 
        //info
        jsondata.add("info", ISCONFIGSET_PRIV(eAAMPConfig_InfoLogging));
 
        //tsbInterruptHandling
        jsondata.add("tsbInterruptHandling", ISCONFIGSET_PRIV(eAAMPConfig_InterruptHandling));
 
        /*
         * Audio and subtitle preference
         * Disabled this for XRE supported TSB linear
         */
        if (!ISCONFIGSET_PRIV(eAAMPConfig_XRESupportedTune))
        {
                AampJsonObject jsondataForPreference;
                AampJsonObject audioPreference;
                AampJsonObject subtitlePreference;
                bool aPrefAvail = false;
                bool tPrefAvail = false;
                if((preferredLanguagesList.size() > 0) || !preferredRenditionString.empty() || !preferredLabelsString.empty() || !preferredAudioAccessibilityNode.getSchemeId().empty())
                {
                        aPrefAvail = true;
                        if ((preferredLanguagesList.size() > 0) && (GETCONFIGOWNER_PRIV(eAAMPConfig_PreferredAudioLanguage) > AAMP_DEFAULT_SETTING ))
                        {
                                audioPreference.add("languages", preferredLanguagesList);
                        }
                        if(!preferredRenditionString.empty() && (GETCONFIGOWNER_PRIV(eAAMPConfig_PreferredAudioRendition) > AAMP_DEFAULT_SETTING ))
                        {
                                audioPreference.add("rendition", preferredRenditionString);
                        }
                        if(!preferredLabelsString.empty() && (GETCONFIGOWNER_PRIV(eAAMPConfig_PreferredAudioLabel) > AAMP_DEFAULT_SETTING ))
                        {
                                audioPreference.add("label", preferredLabelsString);
                        }
                        if(!preferredAudioAccessibilityNode.getSchemeId().empty())
                        {
                                AampJsonObject accessiblity;
                                std::string schemeId = preferredAudioAccessibilityNode.getSchemeId();
                                accessiblity.add("schemeId", schemeId);
                                std::string value;
                                if(preferredAudioAccessibilityNode.getTypeName() == "int_value")
                                {
                                        value = std::to_string(preferredAudioAccessibilityNode.getIntValue());
                                }
                                else
                                {
                                        value = preferredAudioAccessibilityNode.getStrValue();
                                }
                                accessiblity.add("value", value);
                                audioPreference.add("accessibility", accessiblity);
                        }
                }
#if 0
        /** Time being disabled due to issues - LLAMA-7953, LLAMA-7760 **/
 
                if((preferredTextLanguagesList.size() > 0) || !preferredTextRenditionString.empty() || !preferredTextLabelString.empty() || !preferredTextAccessibilityNode.getSchemeId().empty())
                {
                        tPrefAvail = true;
                        if ((preferredTextLanguagesList.size() > 0) && (GETCONFIGOWNER_PRIV(eAAMPConfig_PreferredTextLanguage) > AAMP_DEFAULT_SETTING ))
                        {
                                subtitlePreference.add("languages", preferredTextLanguagesList);
                        }
                        if(!preferredTextRenditionString.empty() && (GETCONFIGOWNER_PRIV(eAAMPConfig_PreferredTextRendition) > AAMP_DEFAULT_SETTING ))
                        {
                                subtitlePreference.add("rendition", preferredTextRenditionString);
                        }
                        if(!preferredTextLabelString.empty() && (GETCONFIGOWNER_PRIV(eAAMPConfig_PreferredTextLabel) > AAMP_DEFAULT_SETTING ))
                        {
                                subtitlePreference.add("label", preferredTextLabelString);
                        }
                        if(!preferredTextAccessibilityNode.getSchemeId().empty())
                        {
                                AampJsonObject accessiblity;
                                std::string schemeId = preferredTextAccessibilityNode.getSchemeId();
                                accessiblity.add("schemeId", schemeId);
                                std::string value;
                                if(preferredTextAccessibilityNode.getTypeName() == "int_value")
                                {
                                        value = std::to_string(preferredTextAccessibilityNode.getIntValue());
                                }
                                else
                                {
                                        value = preferredTextAccessibilityNode.getStrValue();
                                }
                                accessiblity.add("value", value);
                                subtitlePreference.add("accessibility", accessiblity);
                        }
                }
#endif
                bool trackAdded = false;
                if(aPrefAvail)
                {
                        jsondataForPreference.add("audio", audioPreference);
                        trackAdded = true;
                }
                if(tPrefAvail)
                {
                        jsondataForPreference.add("text", subtitlePreference);
                        trackAdded = true;
                }
 
                if(trackAdded)
                {
                        jsondata.add("trackPreference", jsondataForPreference);
                }
        }
        
 
        jsonStr = jsondata.print_UnFormatted();
        AAMPLOG_TRACE("%s", jsonStr.c_str());
        std::string remoteUrl = "127.0.0.1:9080/playerconfig";
        long http_error = -1;
        ProcessCustomCurlRequest(remoteUrl, NULL, &http_error, eCURL_POST, jsonStr);
        return http_error;
}
 
 
/** 
 * @brief -To Load needed config from player to aampabr
 */
void PrivateInstanceAAMP::LoadAampAbrConfig()
{
        HybridABRManager::AampAbrConfig mhAampAbrConfig;
        // ABR config values
        GETCONFIGVALUE_PRIV(eAAMPConfig_ABRCacheLife,mhAampAbrConfig.abrCacheLife);
        GETCONFIGVALUE_PRIV(eAAMPConfig_ABRCacheLength,mhAampAbrConfig.abrCacheLength);
        GETCONFIGVALUE_PRIV(eAAMPConfig_ABRSkipDuration,mhAampAbrConfig.abrSkipDuration);
        GETCONFIGVALUE_PRIV(eAAMPConfig_ABRNWConsistency,mhAampAbrConfig.abrNwConsistency);
        GETCONFIGVALUE_PRIV(eAAMPConfig_ABRThresholdSize,mhAampAbrConfig.abrThresholdSize);
        GETCONFIGVALUE_PRIV(eAAMPConfig_MaxABRNWBufferRampUp,mhAampAbrConfig.abrMaxBuffer);
        GETCONFIGVALUE_PRIV(eAAMPConfig_MinABRNWBufferRampDown,mhAampAbrConfig.abrMinBuffer);
        
        // Logging level support on aampabr
 
        mhAampAbrConfig.infologging  = (ISCONFIGSET_PRIV(eAAMPConfig_InfoLogging)  ? 1 :0);
        mhAampAbrConfig.debuglogging = (ISCONFIGSET_PRIV(eAAMPConfig_DebugLogging) ? 1 :0);
        mhAampAbrConfig.tracelogging = (ISCONFIGSET_PRIV(eAAMPConfig_TraceLogging) ? 1:0);
        mhAampAbrConfig.warnlogging  = (ISCONFIGSET_PRIV(eAAMPConfig_WarnLogging) ? 1:0);
 
        mhAbrManager.ReadPlayerConfig(&mhAampAbrConfig);
}
 
/**
 * @brief Get License Custom Data
 */
std::string PrivateInstanceAAMP::GetLicenseCustomData()
{
    std::string customData;
    GETCONFIGVALUE_PRIV(eAAMPConfig_CustomLicenseData,customData);
    return customData;
}
 
/**
 * @brief check if sidecar data available
 */
bool PrivateInstanceAAMP::HasSidecarData()
{
        if (mData != NULL)
        {
                return true;
        }
        return false;
}