AampCacheHandler.cpp

/*
 * If not stated otherwise in this file or this component's license file the
 * following copyright and licenses apply:
 *
 * Copyright 2018 RDK Management
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/
 
/**************************************
* @file AampCacheHandler.cpp
* @brief Cache handler operations for AAMP
**************************************/
 
#include "AampCacheHandler.h"
 
 
/**
 *  @brief Retrieve playlist from cache  
 */
void AampCacheHandler::InsertToPlaylistCache(const std::string url, const GrowableBuffer* buffer, std::string effectiveUrl,bool trackLiveStatus,MediaType fileType)
{
        PlayListCachedData *tmpData,*newtmpData;
        pthread_mutex_lock(&mMutex);
 
        //Initialize AampCacheHandler
        Init();
 
        // First check point , Caching is allowed only if its VOD and for Main Manifest(HLS) for both VOD/Live
        // For Main manifest , fileType will bypass storing for live content
        if(trackLiveStatus==false || fileType==eMEDIATYPE_MANIFEST)
        {
 
                PlaylistCacheIter it = mPlaylistCache.find(url);
                if (it != mPlaylistCache.end())
                {
                        AAMPLOG_INFO("playlist %s already present in cache", url.c_str());
                }
                // insert only if buffer size is less than Max size
                else
                {
                        if(fileType==eMEDIATYPE_MANIFEST && mPlaylistCache.size())
                        {
                                // If new Manifest is inserted which is not present in the cache , flush out other playlist files related with old manifest,
                                ClearPlaylistCache();
                        }
                        // Dont check for CacheSize if Max is configured as unlimited 
                        if(mMaxPlaylistCacheSize == PLAYLIST_CACHE_SIZE_UNLIMITED || (mMaxPlaylistCacheSize != PLAYLIST_CACHE_SIZE_UNLIMITED  && buffer->len < mMaxPlaylistCacheSize))
                        {
                                // Before inserting into cache, need to check if max cache size will exceed or not on adding new data
                                // if more , need to pop out some from same type of playlist
                                bool cacheStoreReady = true;
                                if(mMaxPlaylistCacheSize != PLAYLIST_CACHE_SIZE_UNLIMITED  && ((mCacheStoredSize + buffer->len) > mMaxPlaylistCacheSize))
                                {
                                        AAMPLOG_WARN("Count[%lu]Avail[%d]Needed[%zu] Reached max cache size", mPlaylistCache.size(),mCacheStoredSize,buffer->len);
                                        cacheStoreReady = AllocatePlaylistCacheSlot(fileType,buffer->len);
                                }
                                if(cacheStoreReady)
                                {
                                        tmpData = new PlayListCachedData();
                                        tmpData->mCachedBuffer = new GrowableBuffer();
                                        memset (tmpData->mCachedBuffer, 0, sizeof(GrowableBuffer));
                                        aamp_AppendBytes(tmpData->mCachedBuffer, buffer->ptr, buffer->len );
 
                                        tmpData->mEffectiveUrl = effectiveUrl;
                                        tmpData->mFileType = fileType;
                                        mPlaylistCache[url] = tmpData;
                                        mCacheStoredSize += buffer->len;
                                        AAMPLOG_INFO("Inserted. url %s", url.c_str());
                                        // There are cases where Main url and effective url will be different ( for Main manifest)
                                        // Need to store both the entries with same content data 
                                        // When retune happens within aamp due to failure , effective url wll be asked to read from cached manifest
                                        // When retune happens from JS , regular Main url will be asked to read from cached manifest. 
                                        // So need to have two entries in cache table but both pointing to same CachedBuffer (no space is consumed for storage)
                                        {                                               
                                                // if n only there is diff in url , need to store both
                                                if(url != effectiveUrl)
                                                {
                                                        newtmpData = new PlayListCachedData();
                                                        // Not to allocate for Cachebuffer again , use the same buffer as above
                                                        newtmpData->mCachedBuffer = tmpData->mCachedBuffer;
                                                        newtmpData->mEffectiveUrl = effectiveUrl;
                                                        // This is a duplicate entry
                                                        newtmpData->mDuplicateEntry = true;
                                                        newtmpData->mFileType = fileType;
                                                        mPlaylistCache[effectiveUrl] = newtmpData;
                                                        AAMPLOG_INFO("Added an effective url entry %s", effectiveUrl.c_str());
                                                }
                                        }
                                }
                        }
                }
        }
        pthread_mutex_unlock(&mMutex);
}
 
 
/**
 *  @brief Retrieve playlist from cache
 */
bool AampCacheHandler::RetrieveFromPlaylistCache(const std::string url, GrowableBuffer* buffer, std::string& effectiveUrl)
{
        GrowableBuffer* buf = NULL;
        bool ret; 
        std::string eUrl;
        pthread_mutex_lock(&mMutex);
        PlaylistCacheIter it = mPlaylistCache.find(url);
        if (it != mPlaylistCache.end())
        {
                PlayListCachedData *tmpData = it->second;
                buf = tmpData->mCachedBuffer;
                eUrl = tmpData->mEffectiveUrl;
                buffer->len = 0;
                aamp_AppendBytes(buffer, buf->ptr, buf->len );
                effectiveUrl = eUrl;
                AAMPLOG_TRACE("url %s found", url.c_str());
                ret = true;
        }
        else
        {
                AAMPLOG_TRACE("url %s not found", url.c_str());
                ret = false;
        }
        pthread_mutex_unlock(&mMutex);
        return ret;
}
 
/**
 *  @brief Remove specific playlist cache
 */
void AampCacheHandler::RemoveFromPlaylistCache(const std::string url)
{
        pthread_mutex_lock(&mMutex);
        PlaylistCacheIter it = mPlaylistCache.find(url);
        if (it != mPlaylistCache.end())
        {
                PlayListCachedData *tmpData = it->second;
                if(!tmpData->mDuplicateEntry)
                {
                        aamp_Free(tmpData->mCachedBuffer);
                        SAFE_DELETE(tmpData->mCachedBuffer);
                }
                SAFE_DELETE(tmpData);
 
                AAMPLOG_INFO("Removing Playlist URL %s from Cache", it->first.c_str());
                mPlaylistCache.erase(it);
        }
        else
        {
                AAMPLOG_WARN("Playlist URL %s not found in cache", url.c_str());
        }
        pthread_mutex_unlock(&mMutex);
}
 
/**
 *  @brief Clear playlist cache
 */
void AampCacheHandler::ClearPlaylistCache()
{
        AAMPLOG_INFO("cache size %d", (int)mPlaylistCache.size());
        PlaylistCacheIter it = mPlaylistCache.begin();
        for (;it != mPlaylistCache.end(); it++)
        {
                PlayListCachedData *tmpData = it->second;
                if(!tmpData->mDuplicateEntry)
                {
                        aamp_Free(tmpData->mCachedBuffer);
                        SAFE_DELETE(tmpData->mCachedBuffer);
                }
                SAFE_DELETE(tmpData);
        }
        mCacheStoredSize = 0;
        mPlaylistCache.clear();
}
 
/**
 *  @brief AllocatePlaylistCacheSlot Allocate Slot for adding new playlist
 */
bool AampCacheHandler::AllocatePlaylistCacheSlot(MediaType fileType,size_t newLen)
{
        bool retVal = true;
        size_t freedSize=0;
        if(mPlaylistCache.size())
        {
                if(fileType == eMEDIATYPE_MANIFEST)
                {
                        // This case cannot happen, but for safety need to handle.
                        // If for any reason Main Manifest is pushed after cache is full , better clear all the playlist cached .
                        // As per new Main Manifest  ,new  playlist files need to be downloaded and cached
                        ClearPlaylistCache();
                }
                else // for non main manifest
                {
                PlaylistCacheIter Iter = mPlaylistCache.begin();
                // Two pass to remove the item from cache to create space for caching
                // First pass : Search for same file type to clean, If Video need to be inserted , free another Video type
                //                              if audio type to be inserted , remove older audio type . Same for iframe .
                // Second pass : Even after removing same file type entry ,still not enough space to add new item then remove from other file type ( rare scenario)
                while(Iter != mPlaylistCache.end())
                {
                        PlayListCachedData *tmpData = Iter->second;
                        if(tmpData->mFileType == eMEDIATYPE_MANIFEST || tmpData->mFileType != fileType)
                        {       // Not to remove main manifest file and filetype which are different
                                Iter++;
                                continue;
                        }
                        if(!tmpData->mDuplicateEntry)
                        {
                                freedSize += tmpData->mCachedBuffer->len;
                                aamp_Free(tmpData->mCachedBuffer);
                                SAFE_DELETE(tmpData->mCachedBuffer);
                        }
                        SAFE_DELETE(tmpData);
                        Iter = mPlaylistCache.erase(Iter);
                }
                //Second Pass - if still more cleanup required for space, remove  from other playlist types
                if(freedSize < newLen)
                {
                        Iter = mPlaylistCache.begin();
                        while(Iter != mPlaylistCache.end())
                        {
                                PlayListCachedData *tmpData = Iter->second;
                                if(tmpData->mFileType == eMEDIATYPE_MANIFEST)
                                {       // Not to remove main manifest file
                                        Iter++;
                                        continue;
                                }
                                if(!tmpData->mDuplicateEntry)
                                {
                                        freedSize += tmpData->mCachedBuffer->len;
                                        aamp_Free(tmpData->mCachedBuffer);
                                        SAFE_DELETE(tmpData->mCachedBuffer);
                                }
                                SAFE_DELETE(tmpData);
                                Iter = mPlaylistCache.erase(Iter);
                        }
                }
                mCacheStoredSize -= freedSize;
                // After all freeing still size is not enough to insert , better not allow to insert such huge file
                if(freedSize < newLen)
                        retVal = false;
                }
        }
        return retVal;
}
 
 
/**
 *  @brief Initialization Function
 */
void AampCacheHandler::Init()
{
        //Check if already initialized
        if(true == mInitialized)
                return;
        if(0 != pthread_create(&mAsyncCleanUpTaskThreadId, NULL, &AampCacheThreadFunction, this))
        {
                AAMPLOG_ERR("Failed to create AampCacheHandler thread errno = %d, %s", errno, strerror(errno));
        }
        else
        {
                pthread_mutex_lock(&mCondVarMutex);
                mAsyncThreadStartedFlag = true;
                mAsyncCacheCleanUpThread = true;
                pthread_mutex_unlock(&mCondVarMutex);  //CID:168111 - Missing lock
        }
        mInitialized = true;
}
 
/**
 *  @brief Clear Cache Handler. Exit clean up thread.
 */
void AampCacheHandler::ClearCacheHandler()
{
        //Check if already uninitialized
        if(false == mInitialized)
                return;
 
        mCacheActive = true;
        pthread_mutex_lock(&mCondVarMutex);
        mAsyncCacheCleanUpThread = false;
        pthread_cond_signal(&mCondVar);
        pthread_mutex_unlock(&mCondVarMutex);
        if(mAsyncThreadStartedFlag)
        {
                void *ptr = NULL;
                int rc = pthread_join(mAsyncCleanUpTaskThreadId, &ptr);
                if (rc != 0)
                {
                        AAMPLOG_ERR("***pthread_join AsyncCacheCleanUpTask returned %d(%s)", rc, strerror(rc));
                }
                mAsyncThreadStartedFlag = false;
        }
        ClearPlaylistCache();
 
        //Clear init fragment & track queue
        ClearInitFragCache();
        mInitialized = false;
}
 
/**
 *  @brief Default Constructor
 */
AampCacheHandler::AampCacheHandler(AampLogManager *logObj):
        mCacheStoredSize(0),mAsyncThreadStartedFlag(false),mAsyncCleanUpTaskThreadId(0),mCacheActive(false),
        mAsyncCacheCleanUpThread(false),mMutex(),mCondVarMutex(),mCondVar(),mPlaylistCache()
        ,mMaxPlaylistCacheSize(MAX_PLAYLIST_CACHE_SIZE*1024),mInitialized(false)
        ,mLogObj(logObj)
        ,umInitFragCache(),umCacheTrackQ(),bInitFragCache(false),mInitFragMutex()
        ,MaxInitCacheSlot(MAX_INIT_FRAGMENT_CACHE_PER_TRACK)
{
        pthread_mutex_init(&mMutex, NULL);
        pthread_mutex_init(&mCondVarMutex, NULL);
        pthread_cond_init(&mCondVar, NULL);
 
        pthread_mutex_init(&mInitFragMutex, NULL);
}
 
 
/**
 *  @brief Destructor Function
 */
AampCacheHandler::~AampCacheHandler()
{
        if(true == mInitialized)
                ClearCacheHandler();
        pthread_mutex_destroy(&mMutex);
        pthread_mutex_destroy(&mCondVarMutex);
        pthread_cond_destroy(&mCondVar);
 
        pthread_mutex_destroy(&mInitFragMutex);
}
 
/**
 *  @brief Start playlist caching
 */
void AampCacheHandler::StartPlaylistCache()
{
        mCacheActive = true;
        pthread_mutex_lock(&mCondVarMutex);
        pthread_cond_signal(&mCondVar);
        pthread_mutex_unlock(&mCondVarMutex );
}
 
/**
 *  @brief Stop playlist caching
 */
void AampCacheHandler::StopPlaylistCache()
{
        mCacheActive = false;
        pthread_mutex_lock(&mCondVarMutex);
        pthread_cond_signal(&mCondVar);
        pthread_mutex_unlock(&mCondVarMutex );
}
 
/**
 *  @brief Thread function for Async Cache clean
 */
void AampCacheHandler::AsyncCacheCleanUpTask()
{
        pthread_mutex_lock(&mCondVarMutex);
        while (mAsyncCacheCleanUpThread)
        {
                pthread_cond_wait(&mCondVar, &mCondVarMutex);
                if(!mCacheActive)
                {
                        struct timespec ts;
                        ts = aamp_GetTimespec(10000);
 
                        if(ETIMEDOUT == pthread_cond_timedwait(&mCondVar, &mCondVarMutex, &ts))
                        {
                                AAMPLOG_INFO("[%p] Cacheflush timed out", this);
                                ClearPlaylistCache();
 
                                //Clear init fragment & track queue
                                ClearInitFragCache();
                        }
                }
        }
        pthread_mutex_unlock(&mCondVarMutex);
}
 
/**
 *  @brief SetMaxPlaylistCacheSize - Set Max Cache Size
 */
void AampCacheHandler::SetMaxPlaylistCacheSize(int maxPlaylistCacheSz)
{
        pthread_mutex_lock(&mMutex);
        mMaxPlaylistCacheSize = maxPlaylistCacheSz;
        AAMPLOG_WARN("Setting mMaxPlaylistCacheSize to :%d",maxPlaylistCacheSz);
        pthread_mutex_unlock(&mMutex);  
}
 
/**
 *  @brief IsUrlCached - Check if URL is already cached
 */
bool AampCacheHandler::IsUrlCached(std::string url)
{
        bool retval = false;
        pthread_mutex_lock(&mMutex);
        PlaylistCacheIter it = mPlaylistCache.find(url);
        if (it != mPlaylistCache.end())
                retval = true;
 
        pthread_mutex_unlock(&mMutex);
        return retval;
}
 
 
/**
 *  @brief Insert init fragment into cache table
 */
void AampCacheHandler::InsertToInitFragCache(const std::string url, const GrowableBuffer* buffer,
                                                std::string effectiveUrl, MediaType fileType)
{
        InitFragCacheStruct *NewInitData;
        InitFragTrackStruct *NewTrackQueueCache;
 
        pthread_mutex_lock(&mInitFragMutex);
 
        InitFragCacheIter Iter = umInitFragCache.find(url);
        if ( Iter != umInitFragCache.end() )
        {
                AAMPLOG_INFO("playlist %s already present in cache", url.c_str());
        }
        else
        {
                NewInitData = new playlistcacheddata();
                NewInitData->mCachedBuffer = new GrowableBuffer();
                memset (NewInitData->mCachedBuffer, 0, sizeof(GrowableBuffer));
                aamp_AppendBytes(NewInitData->mCachedBuffer, buffer->ptr, buffer->len );
 
                NewInitData->mEffectiveUrl = effectiveUrl;
                NewInitData->mFileType = fileType;
                NewInitData->mDuplicateEntry = (effectiveUrl.length() && (effectiveUrl!=url));
 
                /* 
                 * Check if queue created for given track type, if not create a queue
                 * and add a corresponding url into a track queue.
                 */
                CacheTrackQueueIter IterCq = umCacheTrackQ.find(fileType);
                if(IterCq == umCacheTrackQ.end())
                {
                        NewTrackQueueCache = new initfragtrackstruct();
                        NewTrackQueueCache->Trackqueue.push(url);
 
                        umCacheTrackQ[fileType]=NewTrackQueueCache;
                }
                else
                {
                        NewTrackQueueCache = IterCq->second;
                        NewTrackQueueCache->Trackqueue.push(url);
                }
 
 
                /* 
                 * If track queue of given filetype reached maximum limit, remove the very first
                 * inserted entry & its duplicate entry from cache table.
                 */
                if ( NewTrackQueueCache->Trackqueue.size() > MaxInitCacheSlot )
                {
                        RemoveInitFragCacheEntry ( fileType );
                }
 
                umInitFragCache[url] = NewInitData;
                AAMPLOG_INFO("Inserted init url %s", url.c_str());
 
 
                /* 
                 * If current init fragment has any redirected url which is different, that must be
                 * inserted in cache table with same init fragment data of url and which will not inserted in track queue.
                 */
                if ( NewInitData->mDuplicateEntry )
                {
                        InitFragCacheStruct *DupInitData;
                        DupInitData = new playlistcacheddata();
                        DupInitData->mCachedBuffer = NewInitData->mCachedBuffer;
                        DupInitData->mEffectiveUrl = effectiveUrl;
                        DupInitData->mFileType = fileType;
                        umInitFragCache[effectiveUrl] = DupInitData;
        
                        AAMPLOG_INFO("Inserted effective init url %s", url.c_str());
                }
 
                AAMPLOG_INFO("Size [CacheTable:%lu,TrackQ:%lu,CurrentTrack:%lu,MaxLimit:%d]\n", umInitFragCache.size(),umCacheTrackQ.size(),
                                                NewTrackQueueCache->Trackqueue.size(),
                                                MaxInitCacheSlot );
        }
 
        pthread_mutex_unlock(&mInitFragMutex);
}
 
/**
 *  @brief Retrieve init fragment from cache
 */
bool AampCacheHandler::RetrieveFromInitFragCache(const std::string url, GrowableBuffer* buffer,
                                                                        std::string& effectiveUrl)
{
        GrowableBuffer* buf = NULL;
        bool ret;
        std::string eUrl;
        pthread_mutex_lock(&mInitFragMutex);
        InitFragCacheIter it = umInitFragCache.find(url);
        if (it != umInitFragCache.end())
        {
                InitFragCacheStruct *findFragData = it->second;
                buf = findFragData->mCachedBuffer;
                eUrl = findFragData->mEffectiveUrl;
                buffer->len = 0;
                aamp_AppendBytes(buffer, buf->ptr, buf->len );
                effectiveUrl = eUrl;
                AAMPLOG_INFO("url %s found", url.c_str());
                ret = true;
        }
        else
        {
                AAMPLOG_INFO("url %s not found", url.c_str());
                ret = false;
        }
        pthread_mutex_unlock(&mInitFragMutex);
        return ret;
}
 
/**
 *  @brief Removes very first inserted entry ( and duplicate entry, if present)  of given filetype
 *         from fragment cache table in FIFO order, also removes the corresponding url from track queue.
 */ 
void AampCacheHandler::RemoveInitFragCacheEntry ( MediaType fileType )
{
        CacheTrackQueueIter IterCq = umCacheTrackQ.find(fileType);
        if(IterCq == umCacheTrackQ.end())
        {
                return;
        }
 
        InitFragTrackStruct *QueperTrack = IterCq->second;
 
        /* Delete data in FIFO order
         * Get url from Track Queue, which is used to
         * remove fragment entry from cache table in FIFO order.
         */
        InitFragCacheIter Iter = umInitFragCache.find(QueperTrack->Trackqueue.front());
        if (Iter != umInitFragCache.end())
        {
                InitFragCacheStruct *removeCacheData = Iter->second;
 
                /* Remove duplicate entry
                 * Check if the first inserted data has any duplicate entry, If so
                 * then delete the duplicat entry as well.
                 */
                if ( removeCacheData->mDuplicateEntry )
                {
                        InitFragCacheStruct *dupData;
                        InitFragCacheIter IterDup = umInitFragCache.find(removeCacheData->mEffectiveUrl);
                        if(IterDup != umInitFragCache.end())
                        {
                                dupData = IterDup->second;
                                SAFE_DELETE(dupData);
                                umInitFragCache.erase(IterDup);
                                AAMPLOG_INFO("Removed dup url:%s",removeCacheData->mEffectiveUrl.c_str());
                        }
                }
                aamp_Free(removeCacheData->mCachedBuffer);
                SAFE_DELETE(removeCacheData->mCachedBuffer);
                SAFE_DELETE(removeCacheData);
                umInitFragCache.erase(Iter);
                AAMPLOG_INFO("Removed main url:%s",QueperTrack->Trackqueue.front().c_str());
 
                // Remove the url entry from corresponding track queue.
                QueperTrack->Trackqueue.pop();
        }
}
 
/**
 *  @brief Clear init fragment cache & track queue table
 */
void AampCacheHandler::ClearInitFragCache()
{
        AAMPLOG_INFO("Fragment cache size %d", (int)umInitFragCache.size());
        InitFragCacheIter it = umInitFragCache.begin();
        for (;it != umInitFragCache.end(); it++)
        {
                InitFragCacheStruct *delData = it->second;
                if(!delData->mDuplicateEntry)
                {
                        aamp_Free(delData->mCachedBuffer);
                        SAFE_DELETE(delData->mCachedBuffer);
                }
                SAFE_DELETE(delData);
        }
        umInitFragCache.clear();
 
        AAMPLOG_INFO("Track queue size %d", (int)umCacheTrackQ.size());
        CacheTrackQueueIter IterCq = umCacheTrackQ.begin();
        for (;IterCq != umCacheTrackQ.end(); IterCq++)
        {
                InitFragTrackStruct *delTrack = IterCq->second;
 
                std::queue<std::string>().swap(delTrack->Trackqueue);
                SAFE_DELETE(delTrack);
        }
        umCacheTrackQ.clear();
}
 
/**
 *  @brief SetMaxInitFragCacheSize - Set Max Cache Size
 */
void AampCacheHandler::SetMaxInitFragCacheSize(int maxInitFragCacheSz)
{
        pthread_mutex_lock(&mInitFragMutex);
        MaxInitCacheSlot = maxInitFragCacheSz;
        AAMPLOG_WARN("Setting mMaxPlaylistCacheSize to :%d",maxInitFragCacheSz);
        pthread_mutex_unlock(&mInitFragMutex);  
}