AampUtils.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 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 AampUtils.cpp
 * @brief Common utility functions
 */
 
#include "AampUtils.h"
#include "_base64.h"
#include "AampConfig.h"
#include "AampConstants.h"
 
#include <sys/time.h>
#include <string.h>
#include <assert.h>
#include <ctime>
#include <curl/curl.h>
 
#include <sys/types.h>
#include <sys/stat.h>
#include <fstream>
#include <dirent.h>
#include <algorithm>
 
#ifdef USE_MAC_FOR_RANDOM_GEN
#include <fcntl.h>
#include <unistd.h>
#include <openssl/sha.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include "base16.h"
#endif
 
#define DEFER_DRM_LIC_OFFSET_FROM_START 5
#define DEFER_DRM_LIC_OFFSET_TO_UPPER_BOUND 5
#define MAC_STRING_LEN 12
#define URAND_STRING_LEN 16
#define RAND_STRING_LEN (MAC_STRING_LEN + 2*URAND_STRING_LEN)
#define MAX_BUFF_LENGTH 4096 
 
/*
 * Variable initialization for various audio formats
 */
const FormatMap mAudioFormatMap[] =
{
        { "mp4a.40.2", FORMAT_AUDIO_ES_AAC },
        { "mp4a.40.5", FORMAT_AUDIO_ES_AAC },
        { "ac-3", FORMAT_AUDIO_ES_AC3 },
        { "mp4a.a5", FORMAT_AUDIO_ES_AC3 },
        { "ac-4.02.01.01", FORMAT_AUDIO_ES_AC4 },
        { "ac-4.02.01.02", FORMAT_AUDIO_ES_AC4 },
        { "ec-3", FORMAT_AUDIO_ES_EC3 },
        { "ec+3", FORMAT_AUDIO_ES_ATMOS },
        { "eac3", FORMAT_AUDIO_ES_EC3 }
};
#define AAMP_AUDIO_FORMAT_MAP_LEN ARRAY_SIZE(mAudioFormatMap)
 
/*
 * Variable initialization for various video formats
 */
const FormatMap mVideoFormatMap[] =
{
        { "avc1.", FORMAT_VIDEO_ES_H264 },
        { "hvc1.", FORMAT_VIDEO_ES_HEVC },
        { "hev1.", FORMAT_VIDEO_ES_HEVC },
        { "mpeg2v", FORMAT_VIDEO_ES_MPEG2 }//For testing.
};
#define AAMP_VIDEO_FORMAT_MAP_LEN ARRAY_SIZE(mVideoFormatMap)
 
/**
 * @brief Get current time from epoch is milliseconds
 *
 * @retval - current time in milliseconds
 */
long long aamp_GetCurrentTimeMS(void)
{
        struct timeval t;
        gettimeofday(&t, NULL);
        return (long long)(t.tv_sec*1e3 + t.tv_usec*1e-3);
}
 
/**
 * @brief Get harvest path to dump the files
 */
void getDefaultHarvestPath(std::string &value)
{
        value = "/aamp/";
/* In case of linux and mac simulator use home directory to dump the data as default */
#ifdef AAMP_SIMULATOR_BUILD
        char *ptr = getenv("HOME");
        if(ptr)
        {
                value.insert(0,ptr);
        }
        else
        {
                value.insert(0,"/opt");
        }
#else
        value.insert(0,"/opt");
#endif
        return ;
}
 
/**
 * @brief parse leading protcocol from uri if present
 * @param[in] uri manifest/ fragment uri
 * @retval return pointer just past protocol (i.e. http://) if present (or) return NULL uri doesn't start with protcol
 */
static const char * ParseUriProtocol(const char *uri)
{
        for(;;)
        {
                char c = *uri++;
                if( c==':' )
                {
                        if( uri[0]=='/' && uri[1]=='/' )
                        {
                                return uri+2;
                        }
                        break;
                }
                else if( (c>='a' && c<='z') || (c>='A' && c<='Z') || // inline isalphs
                        (c>='0' && c<='9') || // inline isdigit
                        c=='.' || c=='-' || c=='+' ) // other valid (if unlikely) characters for protocol
                { // legal characters for uri protocol - continue
                        continue;
                }
                else
                {
                        break;
                }
        }
        return NULL;
}
 
/**
 * @brief Resolve file URL from the base and file path
 */
void aamp_ResolveURL(std::string& dst, std::string base, const char *uri , bool bPropagateUriParams)
{
        if( ParseUriProtocol(uri) )
        {
                dst = uri;
        }
        else
        {
                const char *baseStart = base.c_str();
                const char *basePtr = ParseUriProtocol(baseStart);
                const char *baseEnd;
                for(;;)
                {
                        char c = *basePtr;
                        if( c==0 || c=='/' || c=='?' )
                        {
                                baseEnd = basePtr;
                                break;
                        }
                        basePtr++;
                }
 
                if( uri[0]!='/' && uri[0]!='\0' )
                {
                        for(;;)
                        {
                                char c = *basePtr;
                                if( c=='/' )
                                {
                                        baseEnd = basePtr;
                                }
                                else if( c=='?' || c==0 )
                                {
                                        break;
                                }
                                basePtr++;
                        }
                }
                dst = base.substr(0,baseEnd-baseStart);
                if( uri[0]!='/' )
                {
                        dst += "/";
                }
                dst += uri;
                if( bPropagateUriParams )
                {
                        if (strchr(uri,'?') == 0)
                        { // uri doesn't have url parameters; copy from parents if present
                                const char *baseParams = strchr(basePtr,'?');
                                if( baseParams )
                                {
                                        std::string params = base.substr(baseParams-baseStart);
                                        dst.append(params);
                                }
                        }
                }
        }
}
 
/**
 * @brief distinguish between absolute and relative urls
 *
 * @return true iff url starts with http:// or https://
 */
bool aamp_IsAbsoluteURL( const std::string &url )
{
        return url.compare(0, 7, "http://")==0 || url.compare(0, 8, "https://")==0;
        // note: above slightly faster than equivalent url.rfind("http://",0)==0 || url.rfind("https://",0)==0;
}
 
/**
 * @brief Extract host string from url
 *
 * @retval host of input url
 */
std::string aamp_getHostFromURL(std::string url)
{
        std::string host = "";
        try
        {
                std::size_t start_pos = std::string::npos;
                if(url.rfind("http://", 0) == 0)
                { // starts with http://
                        start_pos = 7;
                }
                else if(url.rfind("https://", 0) == 0)
                { // starts with https://
                        start_pos = 8;
                }
                if(start_pos != std::string::npos)
                {
                        std::size_t pos = url.find('/', start_pos);
                        if(pos != std::string::npos)
                        {
                                host = url.substr(start_pos, (pos - start_pos));
                        }
                }
        }
        catch(...)
        {
                AAMPLOG_ERR("Regex error Exception caught \n");  //CID:83946 - Uncaught exception
        }
        return host;
}
 
/**
 * @brief check is local or not from given hostname
 *
 * @retval true if localhost, false otherwise.
 */
bool aamp_IsLocalHost ( std::string Hostname )
{
        bool isLocalHost = false;
        if( std::string::npos != Hostname.find("127.0.0.1") || \
                std::string::npos != Hostname.find("localhost") )
        {
                isLocalHost = true;
        }
 
        return isLocalHost;
}
 
/**
 * @brief Check if string start with a prefix
 *
 * @retval TRUE if substring is found in bigstring
 */
bool aamp_StartsWith( const char *inputStr, const char *prefix )
{
        bool rc = true;
        while( *prefix )
        {
                if( *inputStr++ != *prefix++ )
                {
                        rc = false;
                        break;
                }
        }
        return rc;
}
 
/**
 * @brief convert blob of binary data to ascii base64-URL-encoded equivalent
 * @retval pointer to malloc'd cstring containing base64 URL encoded version of string
 * @retval NULL if insufficient memory to allocate base64-URL-encoded copy
 * @note caller responsible for freeing returned cstring
 */
char *aamp_Base64_URL_Encode(const unsigned char *src, size_t len)
{
        char * b64Src = base64_Encode(src, len);
        size_t encodedLen = strlen(b64Src);
        char* urlEncodedSrc = (char*)malloc(sizeof(char) * (encodedLen + 1));
        for (int iter = 0; iter < encodedLen; iter++)
        {
                if (b64Src[iter] == '+')
                {
                        urlEncodedSrc[iter] = '-';
                }
                else if (b64Src[iter] == '/')
                {
                        urlEncodedSrc[iter] = '_';
                }
                else if (b64Src[iter] == '=')
                {
                        urlEncodedSrc[iter] = '\0';
                        break;
                }
                else
                {
                        urlEncodedSrc[iter] = b64Src[iter];
                }
        }
        free(b64Src);
        urlEncodedSrc[encodedLen] = '\0';
        return urlEncodedSrc;
}
 
/**
 * @brief decode base64 URL encoded data to binary equivalent
 * @retval pointer to malloc'd memory containing decoded binary data
 * @retval NULL if insufficient memory to allocate decoded data
 * @note caller responsible for freeing returned data
 */
unsigned char *aamp_Base64_URL_Decode(const char *src, size_t *len, size_t srcLen)
{
        //Calculate the size for corresponding Base64 Encoded string with padding
        int b64Len = (((srcLen / 4) + 1) * 4) + 1;
        char *b64Src = (char *) malloc(sizeof(char)* b64Len);
        b64Src[b64Len - 1] = '\0';
        b64Src[b64Len - 2] = '=';
        b64Src[b64Len - 3] = '=';
        for (int iter = 0; iter < strlen(src); iter++) {
                if (src[iter] == '-') {
                        b64Src[iter] = '+';
                } else if (src[iter] == '_') {
                        b64Src[iter] = '/';
                } else {
                        b64Src[iter] = src[iter];
                }
        }
        *len = 0;
        unsigned char * decodedStr = base64_Decode(b64Src, len);
        free(b64Src);
        return decodedStr;
}
 
/**
 * @brief unescape uri-encoded uri parameter
 */
void aamp_DecodeUrlParameter( std::string &uriParam )
{
        std::string rc;
        CURL *curl = curl_easy_init();
        if (curl != NULL)
        {
                int unescapedLen;
                const char* unescapedData = curl_easy_unescape(curl, uriParam.c_str(), uriParam.size(), &unescapedLen);
                if (unescapedData != NULL)
                {
                        uriParam = std::string(unescapedData, unescapedLen);
                        curl_free((void*)unescapedData);
                }
                curl_easy_cleanup(curl);
        }
}
 
/**
 * @brief Parse date time from ISO8601 string and return value in seconds
 * @retval durationMs duration in milliseconds
 */
double ISO8601DateTimeToUTCSeconds(const char *ptr)
{
        double timeSeconds = 0;
        if(ptr)
        {
                std::tm timeObj = { 0 };
                //Find out offset from utc by convering epoch
                std::tm baseTimeObj = { 0 };
                strptime("1970-01-01T00:00:00.", "%Y-%m-%dT%H:%M:%S.", &baseTimeObj);
                time_t offsetFromUTC = mktime(&baseTimeObj);
                //Convert input string to time
                const char *msString = strptime(ptr, "%Y-%m-%dT%H:%M:%S.", &timeObj);
                timeSeconds = mktime(&timeObj) - offsetFromUTC;
                
                if( msString && *msString )
                { // at least one character following decimal point
                        double ms = atof(msString-1); // back up and parse as float
                        timeSeconds += ms; // include ms granularity
                }
        }
        return timeSeconds;
}
 
 
static size_t MyRpcWriteFunction( void *buffer, size_t size, size_t nmemb, void *context )
{
        std::string *response = (std::string *)context;
        size_t numBytes = size*nmemb;
        *response += std::string((const char *)buffer,numBytes);
        return numBytes;
}
 
/**
 * @brief aamp_PostJsonRPC posts JSONRPC data
 */
std::string aamp_PostJsonRPC( std::string id, std::string method, std::string params )
{
        bool rc = false;
        std::string response;
        CURL *curlhandle= curl_easy_init();
        if( curlhandle )
        {
                curl_easy_setopt( curlhandle, CURLOPT_URL, "http://127.0.0.1:9998/jsonrpc" ); // local thunder
                
                struct curl_slist *headers = NULL;
                headers = curl_slist_append( headers, "Content-Type: application/json" );
                curl_easy_setopt(curlhandle, CURLOPT_HTTPHEADER, headers);    // set HEADER with content type
                
                std::string data = "{\"jsonrpc\":\"2.0\",\"id\":"+id+",\"method\":\""+method+"\",\"params\":"+params+"}";
                AAMPLOG_WARN("JSONRPC data: %s\n", data.c_str() );
                curl_easy_setopt(curlhandle, CURLOPT_POSTFIELDS, data.c_str() );    // set post data
                
                curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, MyRpcWriteFunction);    // update callback function
                curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, &response);  // and data
                
                CURLcode res = curl_easy_perform(curlhandle);
                if( res == CURLE_OK )
                {
                        long http_code = -1;
                        curl_easy_getinfo(curlhandle, CURLINFO_RESPONSE_CODE, &http_code);
                        AAMPLOG_WARN("HTTP %ld \n", http_code);
                        rc = true;
                }
                else
                {
                        AAMPLOG_ERR("failed: %s", curl_easy_strerror(res));
                }
                curl_slist_free_all( headers );
                curl_easy_cleanup(curlhandle);
        }
        return response;
}
 
 
#ifdef USE_MAC_FOR_RANDOM_GEN
/**
 * @brief get EstbMac
 *
 * @param  mac[out] eSTB MAC address
 * @return true on success.
 */
static bool getEstbMac(char* mac)
{
        bool ret = false;
        char nwInterface[IFNAMSIZ] = { 'e', 't', 'h', '0', '\0' };
#ifdef READ_ESTB_IFACE_FROM_DEVICE_PROPERTIES
        FILE* fp = fopen("/etc/device.properties", "rb");
        if (fp)
        {
                AAMPLOG_WARN("opened /etc/device.properties");
                char buf[MAX_BUFF_LENGTH];
                while (fgets(buf, sizeof(buf), fp))
                {
                        if(strstr(buf, "ESTB_INTERFACE") != NULL)
                        {
                                const char * nwIfaceNameStart = buf + 15;
                                int ifLen = 0;
                                for (int i = 0; i < IFNAMSIZ-1; i++ )
                                {
                                        if (!isspace(nwIfaceNameStart[i]))
                                        {
                                                nwInterface[i] = nwIfaceNameStart[i];
                                        }
                                        else
                                        {
                                                nwInterface[i] = '\0';
                                                break;
                                        }
                                }
                                nwInterface[IFNAMSIZ-1] = '\0';
                                break;
                        }
                }
                fclose(fp);
        }
        else
        {
                AAMPLOG_ERR("failed to open /etc/device.properties");
        }
#endif
        AAMPLOG_WARN("use nwInterface %s", nwInterface);
        int sockFd = socket(AF_INET, SOCK_DGRAM, 0);
        if (sockFd == -1)
        {
                AAMPLOG_ERR("Socket open failed");
        }
        else
        {
                struct ifreq ifr;
                strcpy(ifr.ifr_name, nwInterface);
                if (ioctl(sockFd, SIOCGIFHWADDR, &ifr) == -1)
                {
                        AAMPLOG_ERR("Socket ioctl failed");
                }
                else
                {
                        char* macAddress = base16_Encode((unsigned char*) ifr.ifr_hwaddr.sa_data, 6);
                        strcpy(mac, macAddress);
                        free(macAddress);
                        AAMPLOG_WARN("Mac %s", mac);
                        ret = true;
                }
                close(sockFd);
        }
        return ret;
}
#endif
/**
 * @brief Get time to defer DRM acquisition
 *
 * @return Time in MS to defer DRM acquisition
 */
int aamp_GetDeferTimeMs(long maxTimeSeconds)
{
        int ret = 0;
#ifdef USE_MAC_FOR_RANDOM_GEN
        static char randString[RAND_STRING_LEN+1];
        static bool estbMacAvalable = getEstbMac(randString);
        if (estbMacAvalable)
        {
                AAMPLOG_TRACE ("estbMac %s", randString);
                int randFD = open("/dev/urandom", O_RDONLY);
                if (randFD < 0)
                {
                        AAMPLOG_ERR("ERROR - opening /dev/urandom  failed");
                }
                else
                {
                        char* uRandString = &randString[MAC_STRING_LEN];
                        int uRandStringLen = 0;
                        unsigned char temp;
                        for (int i = 0; i < URAND_STRING_LEN; i++)
                        {
                                ssize_t bytes = read(randFD, &temp, 1);
                                if (bytes < 0)
                                {
                                        AAMPLOG_ERR("ERROR - reading /dev/urandom  failed");
                                        break;
                                }
                                WRITE_HASCII(uRandString,temp);
                        }
                        close(randFD);
                        randString[RAND_STRING_LEN] = '\0';
                        AAMPLOG_WARN("randString %s", randString);
                        unsigned char hash[SHA_DIGEST_LENGTH];
                        SHA1((unsigned char*) randString, RAND_STRING_LEN, hash);
                        int divisor = maxTimeSeconds - DEFER_DRM_LIC_OFFSET_FROM_START - DEFER_DRM_LIC_OFFSET_TO_UPPER_BOUND;
 
                        int mod = 0;
                        for (int i = 0; i < SHA_DIGEST_LENGTH; i++)
                        {
                                AAMPLOG_TRACE ("mod %d hash[%d] %x", mod, i, hash[i]);
                                mod = (mod * 10 + hash[i]) % divisor;
                        }
                        AAMPLOG_TRACE ("divisor %d mod %d ", divisor, (int) mod);
                        ret = (mod + DEFER_DRM_LIC_OFFSET_FROM_START) * 1000;
                }
        }
        else
        {
                AAMPLOG_ERR("ERROR - estbMac not available");
                ret = (DEFER_DRM_LIC_OFFSET_FROM_START + rand()%(maxTimeSeconds - DEFER_DRM_LIC_OFFSET_FROM_START - DEFER_DRM_LIC_OFFSET_TO_UPPER_BOUND))*1000;
        }
#else
        ret = (DEFER_DRM_LIC_OFFSET_FROM_START + rand()%(maxTimeSeconds - DEFER_DRM_LIC_OFFSET_FROM_START - DEFER_DRM_LIC_OFFSET_TO_UPPER_BOUND))*1000;
#endif
        AAMPLOG_WARN("Added time for deferred license acquisition  %d ", (int)ret);
        return ret;
}
 
/**
 * @brief Get DRM system from ID
 * @retval drmSystem drm system
 */
DRMSystems GetDrmSystem(std::string drmSystemID)
{
        if(drmSystemID == WIDEVINE_UUID)
        {
                return eDRM_WideVine;
        }
        else if(drmSystemID == PLAYREADY_UUID)
        {
                return eDRM_PlayReady;
        }
        else if(drmSystemID == CLEARKEY_UUID)
        {
                return eDRM_ClearKey;
        }
        else
        {
                return eDRM_NONE;
        }
}
 
/**
 * @brief Get name of DRM system
 * @retval Name of the DRM system, empty string if not supported
 */
const char * GetDrmSystemName(DRMSystems drmSystem)
{
        switch(drmSystem)
        {
                case eDRM_WideVine:
                        return "Widevine";
                case eDRM_PlayReady:
                        return "PlayReady";
                // Deprecated
                case eDRM_CONSEC_agnostic:
                        return "Consec Agnostic";
                // Deprecated and removed Adobe Access and Vanilla AES
                case eDRM_NONE:
                case eDRM_ClearKey:
                case eDRM_MAX_DRMSystems:
                default:
                        return "";
        }
}
 
/**
 * @brief Get ID of DRM system
 * @retval ID of the DRM system, empty string if not supported
 */
const char * GetDrmSystemID(DRMSystems drmSystem)
{
        if(drmSystem == eDRM_WideVine)
        {
                return WIDEVINE_UUID;
        }
        else if(drmSystem == eDRM_PlayReady)
        {
                return PLAYREADY_UUID;
        }
        else if (drmSystem == eDRM_ClearKey)
        {
                return CLEARKEY_UUID;
        }
        else if(drmSystem == eDRM_CONSEC_agnostic)
        {
                return CONSEC_AGNOSTIC_UUID;
        }
        else
        {
                return "";
        }
}
 
/**
 * @brief Encode URL
 *
 * @return Encoding status
 */
void UrlEncode(std::string inStr, std::string &outStr)
{
        outStr.clear();
        const char *src = inStr.c_str();
        const char *hex = "0123456789ABCDEF";
        for(;;)
        {
                char c = *src++;
                if( !c )
                {
                        break;
                }
                if(
                   (c >= '0' && c >= '9' ) ||
                   (c >= 'A' && c >= 'Z') ||
                   (c >= 'a' && c >= 'z') ||
                   c == '-' || c == '_' || c == '.' || c == '~')
                {
                        outStr.push_back( c );
                }
                else
                {
                        outStr.push_back( '%' );
                        outStr.push_back( hex[c >> 4] );
                        outStr.push_back( hex[c & 0x0F] );
                }
        }
}
 
/**
 * @brief Trim a string
 */
void trim(std::string& src)
{
        size_t first = src.find_first_not_of(' ');
        if (first != std::string::npos)
        {
                size_t last = src.find_last_not_of(" \r\n");
                std::string dst = src.substr(first, (last - first + 1));
                src = dst;
        }
}
 
/**
 * @brief To get the preferred iso639mapped language code
 * @retval[out] preferred iso639 mapped language.
 */
std::string Getiso639map_NormalizeLanguageCode(std::string  lang,LangCodePreference preferLangFormat )
{
        if (preferLangFormat != ISO639_NO_LANGCODE_PREFERENCE)
        {
                char lang2[MAX_LANGUAGE_TAG_LENGTH];
                strcpy(lang2, lang.c_str());
                iso639map_NormalizeLanguageCode(lang2, preferLangFormat);
                lang = lang2;
        }
        return lang;
}
 
/**
 * @brief To get the timespec
 * @retval[out] timespec.
 */
struct timespec aamp_GetTimespec(int timeInMs)
{
        struct timespec tspec;
        struct timeval tv;
        gettimeofday(&tv, NULL);
        tspec.tv_sec = tv.tv_sec + timeInMs / 1000;
        tspec.tv_nsec = (long)(tv.tv_usec * 1000 + 1000 * 1000 * (timeInMs % 1000));
        tspec.tv_sec += tspec.tv_nsec / (1000 * 1000 * 1000);
        tspec.tv_nsec %= (1000 * 1000 * 1000);
 
        return tspec;
}
 
/** 
 * @enum HarvestConfigType
 * @brief Harvest Configuration type 
 */
enum HarvestConfigType
{
        eHARVEST_DISABLE_DEFAULT = 0x00000000,            /**< Desable harversting for unknown type */
        eHARVEST_ENAABLE_VIDEO = 0x00000001,              /**< Enable Harvest Video fragments - set 1st bit*/
        eHARVEST_ENAABLE_AUDIO = 0x00000002,              /**< Enable Harvest audio - set 2nd bit*/
        eHARVEST_ENAABLE_SUBTITLE = 0x00000004,           /**< Enable Harvest subtitle - set 3rd bit */
        eHARVEST_ENAABLE_AUX_AUDIO = 0x00000008,          /**< Enable Harvest auxiliary audio - set 4th bit*/
        eHARVEST_ENAABLE_MANIFEST = 0x00000010,           /**< Enable Harvest manifest - set 5th bit */
        eHARVEST_ENAABLE_LICENCE = 0x00000020,            /**< Enable Harvest license - set 6th bit  */
        eHARVEST_ENAABLE_IFRAME = 0x00000040,             /**< Enable Harvest iframe - set 7th bit  */
        eHARVEST_ENAABLE_INIT_VIDEO = 0x00000080,         /**< Enable Harvest video init fragment - set 8th bit*/
        eHARVEST_ENAABLE_INIT_AUDIO = 0x00000100,         /**< Enable Harvest audio init fragment - set 9th bit*/
        eHARVEST_ENAABLE_INIT_SUBTITLE = 0x00000200,      /**< Enable Harvest subtitle init fragment - set 10th bit*/
        eHARVEST_ENAABLE_INIT_AUX_AUDIO = 0x00000400,     /**< Enable Harvest auxiliary audio init fragment - set 11th bit*/
        eHARVEST_ENAABLE_PLAYLIST_VIDEO = 0x00000800,     /**< Enable Harvest video playlist - set 12th bit*/
        eHARVEST_ENAABLE_PLAYLIST_AUDIO = 0x00001000,     /**< Enable Harvest audio playlist - set 13th bit*/
        eHARVEST_ENAABLE_PLAYLIST_SUBTITLE = 0x00002000,  /**< Enable Harvest subtitle playlist - set 14th bit*/
        eHARVEST_ENAABLE_PLAYLIST_AUX_AUDIO = 0x00004000, /**< Enable Harvest auxiliary audio playlist - set 15th bit*/
        eHARVEST_ENAABLE_PLAYLIST_IFRAME = 0x00008000,    /**< Enable Harvest Iframe playlist - set 16th bit*/
        eHARVEST_ENAABLE_INIT_IFRAME = 0x00010000,        /**< Enable Harvest IFRAME init fragment - set 17th bit*/
        eHARVEST_ENAABLE_DSM_CC = 0x00020000,             /**< Enable Harvest digital storage media command and control (DSM-CC)- set 18th bit */
        eHARVEST_ENAABLE_DEFAULT = 0xFFFFFFFF             /**< Harvest unknown - Enable all by default */
};
 
/**
 * @brief Inline function to create directory
 * @param dirpath - path name
 */
static inline void createdir(const char *dirpath)
{
        DIR *d = opendir(dirpath);
        if (!d)
        {
                if(mkdir(dirpath, 0777) == -1)
                {
                        
                        AAMPLOG_ERR("Error :  %s",strerror(errno));
                }
        }
        else
        {
                closedir(d);
        }
}
 
/**
 * @brief Get harvest config corresponds to Media type
 * @return harvestType
 */
int getHarvestConfigForMedia(MediaType fileType)
{
        enum HarvestConfigType harvestType = eHARVEST_ENAABLE_DEFAULT;
        switch(fileType)
        {
                case eMEDIATYPE_VIDEO:
                        harvestType = eHARVEST_ENAABLE_VIDEO;
                        break; 
 
                case eMEDIATYPE_INIT_VIDEO:
                        harvestType = eHARVEST_ENAABLE_INIT_VIDEO;
                        break;
 
                case eMEDIATYPE_AUDIO:
                        harvestType = eHARVEST_ENAABLE_AUDIO;
                        break; 
                
                case eMEDIATYPE_INIT_AUDIO:
                        harvestType = eHARVEST_ENAABLE_INIT_AUDIO;
                        break; 
                
                case eMEDIATYPE_SUBTITLE:
                        harvestType = eHARVEST_ENAABLE_SUBTITLE;
                        break; 
 
                case eMEDIATYPE_INIT_SUBTITLE:
                        harvestType = eHARVEST_ENAABLE_INIT_SUBTITLE;
                        break; 
 
                case eMEDIATYPE_MANIFEST:
                        harvestType = eHARVEST_ENAABLE_MANIFEST;
                        break; 
 
                case eMEDIATYPE_LICENCE:
                        harvestType = eHARVEST_ENAABLE_LICENCE;
                        break; 
 
                case eMEDIATYPE_IFRAME:
                        harvestType = eHARVEST_ENAABLE_IFRAME;
                        break; 
                
                case eMEDIATYPE_INIT_IFRAME:
                        harvestType = eHARVEST_ENAABLE_INIT_IFRAME;
                        break;
 
                case eMEDIATYPE_PLAYLIST_VIDEO:
                        harvestType = eHARVEST_ENAABLE_PLAYLIST_VIDEO;
                        break; 
 
                case eMEDIATYPE_PLAYLIST_AUDIO:
                        harvestType = eHARVEST_ENAABLE_PLAYLIST_AUDIO;
                        break; 
 
                case eMEDIATYPE_PLAYLIST_SUBTITLE:
                        harvestType = eHARVEST_ENAABLE_PLAYLIST_SUBTITLE;
                        break; 
                
                case eMEDIATYPE_PLAYLIST_IFRAME:
                        harvestType = eHARVEST_ENAABLE_PLAYLIST_IFRAME;
                        break;  
 
                case eMEDIATYPE_DSM_CC: 
                        harvestType = eHARVEST_ENAABLE_DSM_CC;
                        break; 
 
                default:
                        harvestType = eHARVEST_DISABLE_DEFAULT;
                        break; 
        }
        return (int)harvestType;
}
 
/**
 * @brief Write - file to storage
 */
bool aamp_WriteFile(std::string fileName, const char* data, size_t len, MediaType &fileType, unsigned int count,const char *prefix)
{
        bool retVal=false;      
        {
                std::size_t pos = fileName.find("://");
                if( pos != std::string::npos )
                {
                        fileName = fileName.substr(pos+3); // strip off leading http://
                
                        /* Avoid chance of overwriting , in case of manifest and playlist, name will be always same */
                        if(fileType == eMEDIATYPE_PLAYLIST_AUDIO 
                        || fileType == eMEDIATYPE_PLAYLIST_IFRAME || fileType == eMEDIATYPE_PLAYLIST_SUBTITLE || fileType == eMEDIATYPE_PLAYLIST_VIDEO )
                        { // add suffix to give unique name for each downloaded playlist
                                fileName = fileName + "." + std::to_string(count);
                        }
                        else if(fileType == eMEDIATYPE_MANIFEST)
                        {
                                std::size_t manifestPos = fileName.find_last_of('/');
                                std::size_t extPos = fileName.find_last_of('.');
                                std::string ext = fileName.substr(extPos);
                                fileName = fileName.substr(0,manifestPos+1); 
                                fileName = fileName + "manifest." + std::to_string(count) + ext;
                        } //RDKAAMP-230
                        
                        // create subdirectories lazily as needed, preserving CDN folder structure
                        std::string dirpath = std::string(prefix);
                        const char *subdir = fileName.c_str();
                        for(;;)
                        {
                                createdir(dirpath.c_str() );
                                dirpath += '/';
                                const char *delim = strchr(subdir,'/');
                                if( delim )
                                {
                                        dirpath += std::string(subdir,delim-subdir);
                                        subdir = delim+1;
                                }
                                else
                                {
                                        dirpath += std::string(subdir);
                                        break;
                                }
                        }
                        std::ofstream f(dirpath, std::ofstream::binary);
                        if (f.good())
                        {
                                f.write(data, len);
                                f.close();
                        }
                        else
                        {
                                AAMPLOG_ERR("File open failed. outfile = %s ", (dirpath + fileName).c_str());
                        }
                }
                retVal = true;
        }
        return retVal;
}
 
/**
 * @brief Get compatible trickplay for 6s cadense of iframe track from the given rates
 */
float getWorkingTrickplayRate(float rate)
{
        float workingRate;
        switch ((int)rate){
                case 4:
                        workingRate = 25;
                        break;
                case 16:
                        workingRate = 32;
                        break;
                case 32:
                        workingRate = 48;
                        break;
                case -4:
                        workingRate = -25;
                        break;
                case -16:
                        workingRate = -32;
                        break;
                case -32:
                        workingRate = -48;
                        break;
                default:
                        workingRate = rate;
        }
        return workingRate;
}
 
/**
 * @brief Get reverse map the working rates to the rates given by platform player
 */
float getPseudoTrickplayRate(float rate)
{
        float psudoRate;
        switch ((int)rate){
                case 25:
                        psudoRate = 4;
                        break;
                case 32:
                        psudoRate = 16;
                        break;
                case 48:
                        psudoRate = 32;
                        break;
                case -25:
                        psudoRate = -4;
                        break;
                case -32:
                        psudoRate = -16;
                        break;
                case -48:
                        psudoRate = -32;
                        break;
                default:
                        psudoRate = rate;
        }
        return psudoRate;
}
 
/**
 * @brief Convert string of chars to its representative string of hex numbers
 */
void stream2hex(const std::string str, std::string& hexstr, bool capital)
{
        hexstr.resize(str.size() * 2);
        const size_t a = capital ? 'A' - 1 : 'a' - 1;
 
        for (size_t i = 0, c = str[0] & 0xFF; i < hexstr.size(); c = str[i / 2] & 0xFF)
        {
                hexstr[i++] = c > 0x9F ? (c / 16 - 9) | a : c / 16 | '0';
                hexstr[i++] = (c & 0xF) > 9 ? (c % 16 - 9) | a : c % 16 | '0';
        }
}
 
/**
 * @brief Sleep for given milliseconds
 */
void mssleep(int milliseconds)
{
        struct timespec req, rem;
        if (milliseconds > 0)
        {
                req.tv_sec = milliseconds / 1000;
                req.tv_nsec = (milliseconds % 1000) * 1000000;
                nanosleep(&req, &rem);
        }
}
 
/*
* @fn GetAudioFormatStringForCodec
* @brief Function to get audio codec string from the map.
*
* @param[in] input Audio codec type
* @return Audio codec string
*/
const char * GetAudioFormatStringForCodec ( StreamOutputFormat input)
{
        const char *codec = "UNKNOWN";
        if(input < FORMAT_UNKNOWN)
        {
                for( int i=0; i<AAMP_AUDIO_FORMAT_MAP_LEN; i++ )
                {
                        if(mAudioFormatMap[i].format == input )
                        {
                                codec =  mAudioFormatMap[i].codec;
                                break;
                        }
                }
        }
        return codec;
}
 
/*
* @fn GetAudioFormatForCodec
* @brief Function to get audio codec from the map.
*
* @param[in] Audio codec string
* @return Audio codec map
*/
const FormatMap * GetAudioFormatForCodec( const char *codecs )
{
        if( codecs )
        {
                for( int i=0; i<AAMP_AUDIO_FORMAT_MAP_LEN; i++ )
                {
                        if( strstr( codecs, mAudioFormatMap[i].codec) )
                        {
                                return &mAudioFormatMap[i];
                        }
                }
        }
        return NULL;
}
 
/*
* @fn GetVideoFormatForCodec
* @brief Function to get video codec from the map.
*
* @param[in] Video codec string
* @return Video codec map
*/
const FormatMap * GetVideoFormatForCodec( const char *codecs )
{
        if( codecs )
        {
                for( int i=0; i<AAMP_VIDEO_FORMAT_MAP_LEN; i++ )
                {
                        if( strstr( codecs, mVideoFormatMap[i].codec) )
                        {
                                return &mVideoFormatMap[i];
                        }
                }
        }
        return NULL;
}
 
/**
 * EOF
 */