/*
 * Copyright (C) 2018 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "HEVCUtilities.h"

#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/text/StringHash.h>
#include <wtf/text/StringToIntegerConversion.h>

namespace WebCore {

Optional<HEVCParameterSet> parseHEVCCodecParameters(const String& codecString)
{
    // The format of the 'hevc' codec string is specified in ISO/IEC 14496-15:2014, Annex E.3.
    StringView codecView(codecString);
    auto codecSplit = codecView.split('.');
    auto nextElement = codecSplit.begin();
    if (nextElement == codecSplit.end())
        return WTF::nullopt;

    HEVCParameterSet parameters;

    // Codec identifier: legal values are specified in ISO/IEC 14496-15:2014, section 8:
    parameters.codecName = (*nextElement).toString();
    if (!equal(parameters.codecName, "hvc1") && !equal(parameters.codecName, "hev1"))
        return WTF::nullopt;

    if (++nextElement == codecSplit.end())
        return WTF::nullopt;

    // First element: Optional General Profile Space parameter ['A', 'B', 'C'], mapping to [1, 2, 3]
    // and [0] for absent, then General Profile IDC as a 5-bit decimal number.
    auto profileSpace = *nextElement;
    if (!profileSpace.length())
        return WTF::nullopt;

    auto firstCharacter = profileSpace[0];
    bool hasProfileSpace = firstCharacter >= 'A' && firstCharacter <= 'C';
    if (hasProfileSpace) {
        parameters.generalProfileSpace = 1 + (firstCharacter - 'A');
        profileSpace = profileSpace.substring(1);
    }

    bool isValidProfileIDC = false;
    parameters.generalProfileIDC = toIntegralType<uint8_t>(profileSpace, &isValidProfileIDC);
    if (!isValidProfileIDC)
        return WTF::nullopt;

    if (++nextElement == codecSplit.end())
        return WTF::nullopt;

    // Second element: 32 bit of General Profile Compatibility Flags, in reverse bit order,
    // in hex with leading zeros omitted.
    auto compatibilityFlags = *nextElement;
    bool isValidCompatibilityFlags = false;
    parameters.generalProfileCompatibilityFlags = toIntegralType<uint32_t>(compatibilityFlags, &isValidCompatibilityFlags, 16);
    if (!isValidCompatibilityFlags)
        return WTF::nullopt;

    if (++nextElement == codecSplit.end())
        return WTF::nullopt;

    // Third element: General Tier Flag ['L', 'H'], mapping to [false, true], followed by
    // General Level IDC as a 8-bit decimal number.
    auto generalTier = *nextElement;
    firstCharacter = generalTier[0];
    if (firstCharacter != 'L' && firstCharacter != 'H')
        return WTF::nullopt;

    parameters.generalTierFlag = firstCharacter == 'H';
    bool isValidGeneralLevelIDC = false;
    parameters.generalLevelIDC = toIntegralType<uint8_t>(generalTier.substring(1), &isValidGeneralLevelIDC);
    if (!isValidGeneralLevelIDC)
        return WTF::nullopt;

    // Optional fourth and remaning elements: a sequence of 6 1-byte constraint flags, each byte encoded
    // in hex, and separated by a period, with trailing zero bytes omitted.
    parameters.constraintFlags.fill(0, 6);
    for (auto& flag : parameters.constraintFlags) {
        if (++nextElement == codecSplit.end())
            break;

        bool isValidFlag = false;
        flag = toIntegralType<uint8_t>(*nextElement, &isValidFlag, 16);
        if (!isValidFlag)
            return WTF::nullopt;
    }

    return parameters;
}

static String codecStringForDoViCodecType(const String& codec)
{
    using MapType = HashMap<String, String>;
    static NeverDestroyed<MapType> types = std::initializer_list<MapType::KeyValuePairType>({
        { "dvhe", "hev1" },
        { "dvh1", "hvc1" },
        { "dvav", "avc3" },
        { "dva1", "avc1" }
    });

    auto findResults = types.get().find(codec);
    if (findResults == types.get().end())
        return nullString();
    return findResults->value;
}

static Optional<unsigned short> profileIDForAlphabeticDoViProfile(const String& profile)
{
    // See Table 7 of "Dolby Vision Profiles and Levels Version 1.3.2"
    using MapType = HashMap<String, unsigned short>;
    static NeverDestroyed<MapType> map = std::initializer_list<MapType::KeyValuePairType>({
        { "dvhe.dtr", 4 },
        { "dvhe.stn", 5 },
        { "dvhe.dtb", 7 },
        { "dvhe.st", 8 },
        { "dvav.se", 9 }
    });

    auto findResults = map.get().find(profile);
    if (findResults == map.get().end())
        return WTF::nullopt;
    return findResults->value;
}

static bool isValidDoViProfileID(unsigned short profileID)
{
    switch (profileID) {
    case 4:
    case 5:
    case 7:
    case 8:
    case 9:
        return true;
    default:
        return false;
    }
}

static Optional<unsigned short> maximumLevelIDForDoViProfileID(unsigned short profileID)
{
    // See Section 4.1 of "Dolby Vision Profiles and Levels Version 1.3.2"
    switch (profileID) {
    case 4: return 9;
    case 5: return 13;
    case 7: return 9;
    case 8: return 13;
    case 9: return 5;
    default: return WTF::nullopt;
    }
}

static bool isValidProfileIDForCodecName(unsigned short profileID, const String& codecName)
{
    if (profileID == 9)
        return codecName == "avc1" || codecName == "avc3";
    return codecName == "hvc1" || codecName == "hev1";
}

Optional<DoViParameterSet> parseDoViCodecParameters(const String& codecString)
{
    // The format of the DoVi codec string is specified in "Dolby Vision Profiles and Levels Version 1.3.2"
    StringView codecView(codecString);
    auto codecSplit = codecView.split('.');
    auto nextElement = codecSplit.begin();
    if (nextElement == codecSplit.end())
        return WTF::nullopt;

    DoViParameterSet parameters;

    parameters.codecName = codecStringForDoViCodecType((*nextElement).toString());
    if (!parameters.codecName)
        return WTF::nullopt;

    if (++nextElement == codecSplit.end())
        return WTF::nullopt;

    auto profileID = *nextElement;
    if (!profileID.length())
        return WTF::nullopt;

    bool isIntegral = false;
    auto firstCharacter = profileID[0];
    // Profile definition can either be numeric or alpha:
    if (firstCharacter == '0') {
        parameters.bitstreamProfileID = toIntegralType<uint8_t>(profileID, &isIntegral, 10);
        if (!isIntegral)
            return WTF::nullopt;
    } else {
        auto alphanumericProfileString = codecView.left(5 + profileID.length()).toString();
        auto profileID = profileIDForAlphabeticDoViProfile(alphanumericProfileString);
        if (!profileID)
            return WTF::nullopt;
        parameters.bitstreamProfileID = profileID.value();
    }

    if (!isValidDoViProfileID(parameters.bitstreamProfileID))
        return WTF::nullopt;

    if (!isValidProfileIDForCodecName(parameters.bitstreamProfileID, parameters.codecName))
        return WTF::nullopt;

    if (++nextElement == codecSplit.end())
        return WTF::nullopt;

    auto levelID = *nextElement;
    if (!levelID.length())
        return WTF::nullopt;

    parameters.bitstreamLevelID = toIntegralType<uint8_t>(levelID, &isIntegral, 10);
    if (!isIntegral)
        return WTF::nullopt;

    auto maximumLevelID = maximumLevelIDForDoViProfileID(parameters.bitstreamProfileID);
    if (!maximumLevelID || parameters.bitstreamLevelID > maximumLevelID.value())
        return WTF::nullopt;

    return parameters;
}

}