AampCacheHandler.h

Go to the documentation of this file.

/*
 * If not stated otherwise in this file or this component's license file the
 * following copyright and licenses apply:
 *
 * Copyright 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.h
 * @brief Cache handler for AAMP
 */
 
#ifndef __AAMP_CACHE_HANDLER_H__
#define __AAMP_CACHE_HANDLER_H__
 
#include <iostream>
#include <memory>
#include <unordered_map>
#include "priv_aamp.h"
 
#define PLAYLIST_CACHE_SIZE_UNLIMITED -1
 
/**
 * @brief PlayListCachedData structure to store playlist data
 */
typedef struct playlistcacheddata{
        std::string mEffectiveUrl;
        GrowableBuffer* mCachedBuffer;
        MediaType mFileType;
        bool mDuplicateEntry;
 
        playlistcacheddata() : mEffectiveUrl(""), mCachedBuffer(NULL), mFileType(eMEDIATYPE_DEFAULT),mDuplicateEntry(false)
        {
        }
 
        playlistcacheddata(const playlistcacheddata& p) : mEffectiveUrl(p.mEffectiveUrl), mCachedBuffer(p.mCachedBuffer), mFileType(p.mFileType),mDuplicateEntry(p.mDuplicateEntry)
        {
                mCachedBuffer->ptr = p.mCachedBuffer->ptr;
                mCachedBuffer->len = p.mCachedBuffer->len;
                mCachedBuffer->avail = p.mCachedBuffer->avail;
        }
 
        playlistcacheddata& operator=(const playlistcacheddata &p)
        {
                mEffectiveUrl = p.mEffectiveUrl;
                mCachedBuffer = p.mCachedBuffer;
                mFileType = p.mFileType;
                mDuplicateEntry = p.mDuplicateEntry;
                return *this;
        }
 
}PlayListCachedData;
 
/**
 * @brief InitFragCacheStruct to store Init Fragment data
 * Init fragment cache mechanism
 * All types (VID/AUD/SUB/AUX) of Init Fragment maintained in a single Cache Table,
 * and these fragment's url are stored in a Track Queue corrsponding to file type.
 * This queue will be used to count fragments inserted, to remove entry in FIFO order
 * upon exceeding limit with respect to file type.
 * Eg:
 * TrackQ[VID]={"http://sample_domain/vid_qual1.init"}     umCacheTable={{"http://sample_domain/vid_qual1.init"}, VidUrlData1}
 *             {"http://sample_domain/vid_qual2.init"}                                  {{"http://sample_domain/vid_qual1.init_redirect"}, VidUrlData1}
 *                         {"http://sample_domain/vid_qual3.init"}                                      {{"http://sample_domain/aud_qual1.init"}, AudUrlData1}
 * TrackQ[AUD]={"http://sample_domain/aud_qual1.init"}                                  {{"http://sample_domain/vid_qual2.init"}, VidUrlData2}
 *             {"http://sample_domain/aud_qual2.init"}                                  {{"http://sample_domain/aud_qual1.init_redirect"}, AudUrlData1}
 *                         {"http://sample_domain/aud_qual3.init"}                                      {{"http://sample_domain/aud_qual3.init"}, AudUrlData3}
 *                                                                                                                                              {{"http://sample_domain/aud_qual2.init"}, AudUrlData2}
 *                                                                                                                                              {{"http://sample_domain/vid_qual2.init_redirect"}, VidUrlData2}
 *                                                                                                                                              {{"http://sample_domain/vid_qual3.init"}, VidUrlData3}
 *                                                                                                                                              {{"http://sample_domain/aud_qual2.init_redirect"}, AudUrlData2}
 * Track queue will not maintain duplicate entry of cache table, so we can have maximum of different init fragments in cache table.
 * As per above eg, TrackQ[VID] size is 3, but cache table has 5 including effective url entry. If we maintain effective url entry
 * in cache queue, we will have only 3 init fragments in diff quality.
 * If cache table reaches max no of cache per track, we remove both main entry and dup entry if present, in FIFO order.
 * 
 * Fragment cache & track queue will be cleared upon exiting from aamp player or from async clear thread.
 */
typedef struct playlistcacheddata InitFragCacheStruct;
 
/**
 * @brief initfragtrackstruct to store init fragment url per media track in FIFO Queue.
 */
typedef struct initfragtrackstruct
{
        std::queue<std::string> Trackqueue;
 
        initfragtrackstruct() : Trackqueue()
        {
        }
}InitFragTrackStruct;
 
/**
 * @class AampCacheHandler
 * @brief Handles Aamp Cahe operations
 */
 
class AampCacheHandler
{
private:
        typedef std::unordered_map<std::string, PlayListCachedData *> PlaylistCache ;
        typedef std::unordered_map<std::string, PlayListCachedData *>::iterator PlaylistCacheIter;
        PlaylistCache mPlaylistCache;
        int mCacheStoredSize;
        bool mInitialized;
        bool mCacheActive;
        bool mAsyncCacheCleanUpThread;
        bool mAsyncThreadStartedFlag;
        int mMaxPlaylistCacheSize;
        pthread_mutex_t mMutex;
        pthread_mutex_t mCondVarMutex;
        pthread_cond_t mCondVar ;
        pthread_t mAsyncCleanUpTaskThreadId;
        AampLogManager *mLogObj;
 
        typedef std::unordered_map <std::string, InitFragCacheStruct*> InitFragCache ;
        typedef std::unordered_map <std::string, InitFragCacheStruct*>::iterator InitFragCacheIter;
        typedef std::unordered_map <MediaType, InitFragTrackStruct*, std::hash<int>> CacheTrackQueue;
        typedef std::unordered_map <MediaType, InitFragTrackStruct*, std::hash<int>>::iterator CacheTrackQueueIter;
        InitFragCache umInitFragCache;
        CacheTrackQueue umCacheTrackQ;
        pthread_mutex_t mInitFragMutex;
        bool bInitFragCache;
        int MaxInitCacheSlot;                                           /**< Max no of init fragment per track */
 
private:
 
        /**
        * @fn Init
        */
        void Init();
 
        /**
        * @fn ClearCacheHandler
        */
        void ClearCacheHandler();
 
        /**
         *       @fn AsyncCacheCleanUpTask
         *
         *       @return void
         */
        void AsyncCacheCleanUpTask();
        /**
         *       @brief Thread entry function
         *
         *       @return void
         */
        static void * AampCacheThreadFunction(void * This) {((AampCacheHandler *)This)->AsyncCacheCleanUpTask(); return NULL;}
        /**
         *       @fn ClearPlaylistCache
         *       @return void
         */
        void ClearPlaylistCache();
        /**
         *   @fn AllocatePlaylistCacheSlot
         *   @param[in] fileType - Indicate the type of playlist to store/remove
         *   @param[in] newLen  - Size required to store new playlist
         *
         *   @return bool Success or Failure
         */
        bool AllocatePlaylistCacheSlot(MediaType fileType,size_t newLen);
 
        /**
         *   @fn ClearInitFragCache
         *
         *   @return void
         */
        void ClearInitFragCache();
 
        /**
         *   @fn RemoveInitFragCacheEntry
         * 
         *   @param fileType type of file format to be removed from cache table
         * 
         *   @return void
         */
        void RemoveInitFragCacheEntry ( MediaType fileType );
 
public:
 
        /**
         *       @fn AampCacheHandler
         *
         *       @return void
         */
        AampCacheHandler(AampLogManager *logObj);
 
        /**
        *        @fn ~AampCacheHandler
        */
        ~AampCacheHandler();
 
        /**
         *       @fn StartPlaylistCache
         *
         *       @return void
         */
        void StartPlaylistCache();
        /**
         *       @fn StopPlaylistCache
         *
         *       @return void
         */
        void StopPlaylistCache();
 
        /**
         *   @fn InsertToPlaylistCache
         *   @param[in] url - URL
         *   @param[in] buffer - Pointer to growable buffer
         *   @param[in] effectiveUrl - Final URL
         *   @param[in] trackLiveStatus - Live Status of the track inserted
         *   @param[in] fileType - Type of the file inserted
         *
         *   @return void
         */
        void InsertToPlaylistCache(const std::string url, const GrowableBuffer* buffer, std::string effectiveUrl,bool trackLiveStatus,MediaType fileType=eMEDIATYPE_DEFAULT);
 
        /**
         *   @fn RetrieveFromPlaylistCache
         *   @param[in] url - URL
         *   @param[out] buffer - Pointer to growable buffer
         *   @param[out] effectiveUrl - Final URL
         *   @return true: found, false: not found
         */
        bool RetrieveFromPlaylistCache(const std::string url, GrowableBuffer* buffer, std::string& effectiveUrl);
 
        /**
         *  @brief Remove specific playlist cache
         *   @param[in] url - URL
         */
        void RemoveFromPlaylistCache(const std::string url);
 
        /**
         *   @fn SetMaxPlaylistCacheSize
         *
         *   @param[in] maxPlaylistCacheSz - CacheSize
         *   @return None
         */
        void SetMaxPlaylistCacheSize(int maxPlaylistCacheSz);
        /**
         *   @brief GetMaxPlaylistCacheSiz   @fn RetrieveFromPlaylistCache - Get present CacheSize
         *
         *   @return int - maxCacheSize
         */
        int  GetMaxPlaylistCacheSize() { return mMaxPlaylistCacheSize; }
        /**
         *   @fn IsUrlCached 
         *
         *   @return bool - true if file found, else false
         */
        bool IsUrlCached(std::string);
 
        /**
         *   @fn InsertToInitFragCache
         *
         *   @param[in] url - URL
         *   @param[in] buffer - Pointer to growable buffer
         *   @param[in] effectiveUrl - Final URL
         *   @param[in] fileType - Type of the file inserted
         *
         *   @return void
         */
        void InsertToInitFragCache(const std::string url, const GrowableBuffer* buffer, std::string effectiveUrl,MediaType fileType);
 
        /**
         *   @fn RetrieveFromInitFragCache
         *
         *   @param[in] url - URL
         *   @param[out] buffer - Pointer to growable buffer
         *   @param[out] effectiveUrl - Final URL
         * 
         *   @return true: found, false: not found
         */
        bool RetrieveFromInitFragCache(const std::string url, GrowableBuffer* buffer, std::string& effectiveUrl);
 
        /**
        *   @fn SetMaxInitFragCacheSize
        *
        *   @param[in] maxInitFragCacheSz - CacheSize
        *
        *   @return None
        */
        void SetMaxInitFragCacheSize( int maxInitFragCacheSz);
 
        /**
        *   @brief GetMaxPlaylistCacheSize - Get present CacheSize
        *
        *   @return int - maxCacheSize
        */
        int  GetMaxInitFragCacheSize() { return MaxInitCacheSlot; }
 
        /**
         * @brief Copy constructor disabled
         *
         */
        AampCacheHandler(const AampCacheHandler&) = delete;
        /**
         * @brief assignment operator disabled
         *
         */
        AampCacheHandler& operator=(const AampCacheHandler&) = delete;
};
 
 
#endif