widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

HLS media playlist EXT-X-KEY format changes

Browse Source 
[ Merged of http://go/wvgerrit/16576 ]

The WV EXT-X-KEY attribute list earlier expected a cenc PSSH box in the
URI field, in a hexadecimal sequence format. To ease the burden on
content providers, the URI field will now contain init data in a json
format and base64 encoded. The platform will assume responsibility
to parse this data and create a widevine init data protobuf that
can be included in the license request.

b/20630275

Change-Id: I49e270bedbe96791fc9b282214a9a358d95d163e
This commit is contained in:
Rahul Frias
2016-01-27 11:17:10 -08:00
parent 1d805385ce
commit 77241489c3
6 changed files with 450 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

244
libwvdrmengine/cdm/core/test/initialization_data_unittest.cpp
View File

@@ -2,6 +2,7 @@
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "initialization_data.h"
#include "string_conversions.h"
#include "wv_cdm_constants.h"
@@ -14,6 +15,21 @@ namespace wvcdm {
namespace {
// Constants for JSON formatting
const std::string kLeftBrace = "{";
const std::string kRightBrace = "}";
const std::string kLeftBracket = "[";
const std::string kRightBracket = "]";
const std::string kComma = ",";
const std::string kColon = ":";
const std::string kDoubleQuote = "\"";
const std::string kNewline = "\n";
const std::string kFourSpaceIndent = " ";
const std::string kJsonProvider = "provider";
const std::string kJsonContentId = "content_id";
const std::string kJsonKeyIds = "key_ids";
const std::string kWidevinePssh = a2bs_hex(
// Widevine PSSH box
"00000042" // atom size
@@ -145,8 +161,6 @@ const std::string kHlsIvHexValue = "6DF49213A781E338628D0E9C812D328E";
const std::string kHlsIvValue = "0x" + kHlsIvHexValue;
const std::string kHlsKeyFormatValue = "com.widevine.alpha";
const std::string kHlsKeyFormatValueOther = "com.example";
const std::string kHlsInitDataHexValue = b2a_hex(kWidevineV1Pssh);
const std::string kHlsInitDataValue = "0x" + kHlsInitDataHexValue;
const std::string kHlsTestKey1 = "TESTKEY1";
const std::string kHlsTestValue1 = "testvalue1";
const std::string kHlsTestKey2 = "TESTKEY2";
@@ -159,62 +173,119 @@ const std::string kHlsTestEmptyHexValue = "";
const std::string kHlsTestNoHexValue = "0x";
const std::string kHlsTestHexValueWithOddBytes = kHlsIvHexValue + "7";
const std::string kHlsTestInvalidHexValue = kHlsIvHexValue + "g7";
char kHlsTestKeyFormatVersionsSeparator = '/';
const std::string kHlsTestUriDataFormat = "data:text/plain;base64,";
const std::string kHlsTestProvider = "youtube";
const std::string kHlsTestContentId = "Tears_2015";
const std::string kHlsTestKeyId1 = "371e135e1a985d75d198a7f41020dc23";
const std::string kHlsTestKeyId2 = "e670d9b60ae61583e01bc9253fa19261";
const std::string kHlsTestKeyId3 = "78094e72165df39721b8a354d6a71390";
const std::string kHlsTestInvalidKeyId = "b8a354d6a71390";
// HLS attribute helper functions
std::string QuoteString(const std::string& value) {
return "\"" + value + "\"";
}
std::string GenerateJsonInitData(const std::string& provider,
const std::string& content_id,
const std::vector<std::string>& key_ids) {
std::string json = kLeftBrace + kNewline;
if (provider.size() > 0) {
json += kFourSpaceIndent + kDoubleQuote + kJsonProvider + kDoubleQuote +
kColon + kDoubleQuote + provider + kDoubleQuote + kComma + kNewline;
}
if (content_id.size() > 0) {
json += kFourSpaceIndent + kDoubleQuote + kJsonContentId + kDoubleQuote +
kColon + kDoubleQuote + content_id + kDoubleQuote + kComma +
kNewline;
}
if (key_ids.size() > 0) {
json += kFourSpaceIndent + kDoubleQuote + kJsonKeyIds + kDoubleQuote +
kColon + kNewline;
json += kFourSpaceIndent + kLeftBracket + kNewline;
for (size_t i = 0; i < key_ids.size(); ++i) {
json += kFourSpaceIndent + kFourSpaceIndent + kDoubleQuote + key_ids[i] +
kDoubleQuote;
if (i != key_ids.size() - 1) {
json += kComma;
}
json += kNewline;
}
json += kFourSpaceIndent + kRightBracket + kNewline;
}
json += kRightBrace + kNewline;
return json;
}
std::string GenerateHlsUriData(const std::string& provider,
const std::string& content_id,
const std::vector<std::string>& key_ids) {
std::string json = GenerateJsonInitData(content_id, provider, key_ids);
std::vector<uint8_t> json_init_data(
reinterpret_cast<const uint8_t*>(json.data()),
reinterpret_cast<const uint8_t*>(json.data() + json.size()));
return kHlsTestUriDataFormat + Base64Encode(json_init_data);
}
std::string CreateHlsAttributeList(const std::string& method,
const std::string& uri,
const std::string& iv,
const std::string& key_format,
const std::string& key_format_version,
const std::string& init_data) {
const std::string& key_format_version) {
return "EXT-X-KEY: " + HLS_METHOD_ATTRIBUTE + "=" + method + "," +
HLS_URI_ATTRIBUTE + "=" + QuoteString(uri) + "," + HLS_IV_ATTRIBUTE +
"=" + iv + "," + HLS_KEYFORMAT_ATTRIBUTE + "=" +
QuoteString(key_format) + "," + HLS_KEYFORMAT_VERSION_ATTRIBUTE + "=" +
QuoteString(key_format_version) + "," + HLS_INITDATA_ATTRIBUTE + "=" +
init_data;
QuoteString(key_format) + "," + HLS_KEYFORMAT_VERSIONS_ATTRIBUTE +
"=" + QuoteString(key_format_version);
}
// HLS Key Format Version lists for testing
std::vector<std::string> kHlsTestKeyFormatVersionsSingleVersion = {"1"};
std::vector<std::string> kHlsTestKeyFormatVersionsSingleVersionExtendedLength =
{"21"};
std::vector<std::string> kHlsTestKeyFormatVersionsTwoVersions = {"1", "2"};
std::vector<std::string> kHlsTestKeyFormatVersionsThreeVersions = {"1", "2",
"5"};
std::vector<std::string> kHlsTestKeyFormatVersionsFourVersions = {"3", "13",
"19", "27"};
// HLS attribute list for testing
const std::string kHlsAttributeList = CreateHlsAttributeList(
HLS_METHOD_SAMPLE_AES, kHlsUriValue, kHlsIvValue, kHlsKeyFormatValue,
HLS_KEYFORMAT_VERSION_VALUE_1, kHlsInitDataValue);
const std::string kHlsAttributeList =
CreateHlsAttributeList(HLS_METHOD_SAMPLE_AES, kHlsUriValue, kHlsIvValue,
kHlsKeyFormatValue, HLS_KEYFORMAT_VERSION_VALUE_1);
const std::string kHlsAttributeListKeyFormatUnknown = CreateHlsAttributeList(
HLS_METHOD_SAMPLE_AES, kHlsUriValue, kHlsIvValue, kHlsKeyFormatValueOther,
HLS_KEYFORMAT_VERSION_VALUE_1, kHlsInitDataValue);
HLS_KEYFORMAT_VERSION_VALUE_1);
const std::string kHlsAttributeListKeyFormatVersionUnsupported =
CreateHlsAttributeList(HLS_METHOD_SAMPLE_AES, kHlsUriValue, kHlsIvValue,
kHlsKeyFormatValue, "2", kHlsInitDataValue);
kHlsKeyFormatValue, "2");
const std::string kHlsAttributeListMethodAes128 = CreateHlsAttributeList(
HLS_METHOD_AES_128, kHlsUriValue, kHlsIvValue, kHlsKeyFormatValue,
HLS_KEYFORMAT_VERSION_VALUE_1, kHlsInitDataValue);
const std::string kHlsAttributeListMethodAes128 =
CreateHlsAttributeList(HLS_METHOD_AES_128, kHlsUriValue, kHlsIvValue,
kHlsKeyFormatValue, HLS_KEYFORMAT_VERSION_VALUE_1);
const std::string kHlsAttributeListMethodNone = CreateHlsAttributeList(
HLS_METHOD_NONE, kHlsUriValue, kHlsIvValue, kHlsKeyFormatValue,
HLS_KEYFORMAT_VERSION_VALUE_1, kHlsInitDataValue);
const std::string kHlsAttributeListMethodNone =
CreateHlsAttributeList(HLS_METHOD_NONE, kHlsUriValue, kHlsIvValue,
kHlsKeyFormatValue, HLS_KEYFORMAT_VERSION_VALUE_1);
const std::string kHlsAttributeListMethodInvalid = CreateHlsAttributeList(
kHlsTestValue1, kHlsUriValue, kHlsIvValue, kHlsKeyFormatValue,
HLS_KEYFORMAT_VERSION_VALUE_1, kHlsInitDataValue);
const std::string kHlsAttributeListMethodInvalid =
CreateHlsAttributeList(kHlsTestValue1, kHlsUriValue, kHlsIvValue,
kHlsKeyFormatValue, HLS_KEYFORMAT_VERSION_VALUE_1);
const std::string kHlsAttributeListInvalidUri = CreateHlsAttributeList(
HLS_METHOD_SAMPLE_AES, kHlsTestValueWithEmbeddedQuote, kHlsIvValue,
kHlsKeyFormatValue, HLS_KEYFORMAT_VERSION_VALUE_1, kHlsInitDataValue);
kHlsKeyFormatValue, HLS_KEYFORMAT_VERSION_VALUE_1);
const std::string kHlsAttributeListInvalidIv = CreateHlsAttributeList(
HLS_METHOD_SAMPLE_AES, kHlsTestHexValueWithOddBytes, kHlsTestNoHexValue,
kHlsKeyFormatValue, HLS_KEYFORMAT_VERSION_VALUE_1, kHlsInitDataValue);
kHlsKeyFormatValue, HLS_KEYFORMAT_VERSION_VALUE_1);
const std::string kHlsAttributeListInvalidInitData = CreateHlsAttributeList(
HLS_METHOD_SAMPLE_AES, kHlsUriValue, kHlsIvValue, kHlsKeyFormatValue,
HLS_KEYFORMAT_VERSION_VALUE_1, kHlsTestInvalidHexValue);
const std::string kHlsAttributeListInvalidInitData =
CreateHlsAttributeList(HLS_METHOD_SAMPLE_AES, kHlsUriValue, kHlsIvValue,
kHlsKeyFormatValue, HLS_KEYFORMAT_VERSION_VALUE_1);
std::string InsertHlsAttributeInList(const std::string key,
const std::string& value) {
@@ -222,6 +293,22 @@ std::string InsertHlsAttributeInList(const std::string key,
"=" + kHlsTestValue2;
}
struct HlsInitDataVariant {
HlsInitDataVariant(const std::string& provider, const std::string& content_id,
const std::string& key_id, bool success)
: provider_(provider), content_id_(content_id), success_(success) {
if (key_id.size() > 0) key_ids_.push_back(key_id);
}
HlsInitDataVariant AddKeyId(const std::string& key_id) {
key_ids_.push_back(key_id);
return *this;
}
const std::string provider_;
const std::string content_id_;
std::vector<std::string> key_ids_;
const bool success_;
};
struct HlsAttributeVariant {
HlsAttributeVariant(const std::string& attribute_list, const std::string& key,
const std::string& value, bool success)
@@ -246,8 +333,13 @@ class HlsHexAttributeExtractionTest
class HlsQuotedAttributeExtractionTest
: public ::testing::TestWithParam<HlsAttributeVariant> {};
class HlsParseTest
: public ::testing::TestWithParam<HlsAttributeVariant> {};
class HlsKeyFormatVersionsExtractionTest
: public ::testing::TestWithParam<std::vector<std::string> > {};
class HlsConstructionTest
: public ::testing::TestWithParam<HlsInitDataVariant> {};
class HlsParseTest : public ::testing::TestWithParam<HlsAttributeVariant> {};
class HlsTest : public ::testing::Test {};
} // namespace
@@ -265,6 +357,37 @@ INSTANTIATE_TEST_CASE_P(ParsePssh, InitializationDataTest,
kWidevineV1Pssh, kOtherBoxFirst,
kZeroSizedPsshBox));
TEST_P(HlsKeyFormatVersionsExtractionTest, ExtractKeyFormatVersions) {
std::vector<std::string> versions = GetParam();
std::string key_format_versions;
for (size_t i = 0; i < versions.size(); ++i) {
key_format_versions += versions[i] + kHlsTestKeyFormatVersionsSeparator;
}
key_format_versions.resize(key_format_versions.size() -
sizeof(kHlsTestKeyFormatVersionsSeparator));
std::vector<std::string> extracted_versions =
InitializationData::ExtractKeyFormatVersions(key_format_versions);
EXPECT_EQ(versions.size(), extracted_versions.size());
for (size_t i = 0; i < versions.size(); ++i) {
bool found = false;
for (size_t j = 0; j < extracted_versions.size(); ++j) {
if (versions[i] == extracted_versions[j]) {
found = true;
break;
}
}
EXPECT_TRUE(found);
}
}
INSTANTIATE_TEST_CASE_P(
HlsTest, HlsKeyFormatVersionsExtractionTest,
::testing::Values(kHlsTestKeyFormatVersionsSingleVersion,
kHlsTestKeyFormatVersionsSingleVersionExtendedLength,
kHlsTestKeyFormatVersionsTwoVersions,
kHlsTestKeyFormatVersionsThreeVersions,
kHlsTestKeyFormatVersionsFourVersions));
TEST_P(HlsAttributeExtractionTest, ExtractAttribute) {
HlsAttributeVariant param = GetParam();
std::string value;
@@ -289,10 +412,8 @@ INSTANTIATE_TEST_CASE_P(
true),
HlsAttributeVariant(kHlsAttributeList, HLS_KEYFORMAT_ATTRIBUTE,
QuoteString(kHlsKeyFormatValue), true),
HlsAttributeVariant(kHlsAttributeList, HLS_KEYFORMAT_VERSION_ATTRIBUTE,
HlsAttributeVariant(kHlsAttributeList, HLS_KEYFORMAT_VERSIONS_ATTRIBUTE,
QuoteString(HLS_KEYFORMAT_VERSION_VALUE_1), true),
HlsAttributeVariant(kHlsAttributeList, HLS_INITDATA_ATTRIBUTE,
kHlsInitDataValue, true),
HlsAttributeVariant(InsertHlsAttributeInList(kHlsTestKey1,
kHlsTestValue1),
kHlsTestKey1, kHlsTestValue1, true),
@@ -349,10 +470,6 @@ INSTANTIATE_TEST_CASE_P(
::testing::Values(
HlsAttributeVariant(kHlsAttributeList, HLS_IV_ATTRIBUTE, kHlsIvHexValue,
true),
HlsAttributeVariant(kHlsAttributeList, HLS_INITDATA_ATTRIBUTE,
kHlsInitDataHexValue, true),
HlsAttributeVariant(kHlsAttributeList, HLS_INITDATA_ATTRIBUTE,
kHlsInitDataHexValue, true),
HlsAttributeVariant(InsertHlsAttributeInList(kHlsTestKey1,
kHlsTestEmptyHexValue),
kHlsTestKey1, kHlsTestEmptyHexValue, false),
@@ -386,7 +503,7 @@ INSTANTIATE_TEST_CASE_P(
true),
HlsAttributeVariant(kHlsAttributeList, HLS_KEYFORMAT_ATTRIBUTE,
kHlsKeyFormatValue, true),
HlsAttributeVariant(kHlsAttributeList, HLS_KEYFORMAT_VERSION_ATTRIBUTE,
HlsAttributeVariant(kHlsAttributeList, HLS_KEYFORMAT_VERSIONS_ATTRIBUTE,
HLS_KEYFORMAT_VERSION_VALUE_1, true),
HlsAttributeVariant(
InsertHlsAttributeInList(kHlsTestKey1, QuoteString(kHlsTestValue1)),
@@ -396,7 +513,41 @@ INSTANTIATE_TEST_CASE_P(
kHlsTestKey1, QuoteString(kHlsTestValueWithEmbeddedQuote)),
kHlsTestKey1, kHlsTestValueWithEmbeddedQuote, false)));
TEST_P(HlsParseTest, Parse) {
TEST_P(HlsConstructionTest, InitData) {
HlsInitDataVariant param = GetParam();
std::string uri =
GenerateHlsUriData(param.provider_, param.content_id_, param.key_ids_);
std::string value;
if (param.success_) {
EXPECT_TRUE(InitializationData::ConstructWidevineInitData(uri, &value));
// EXPECT_EQ(param.value_, value);
} else {
EXPECT_FALSE(InitializationData::ConstructWidevineInitData(uri, &value));
}
}
INSTANTIATE_TEST_CASE_P(
HlsTest, HlsConstructionTest,
::testing::Values(HlsInitDataVariant(std::string(), kHlsTestContentId,
kHlsTestKeyId1, false),
HlsInitDataVariant(kHlsTestProvider, std::string(),
kHlsTestKeyId1, false),
HlsInitDataVariant(kHlsTestProvider, kHlsTestContentId,
std::string(), false),
HlsInitDataVariant(kHlsTestProvider, kHlsTestContentId,
kHlsTestInvalidKeyId, false),
HlsInitDataVariant(kHlsTestProvider, kHlsTestContentId,
kHlsTestKeyId1, true),
HlsInitDataVariant(kHlsTestProvider, kHlsTestContentId,
kHlsTestKeyId1, true)
.AddKeyId(kHlsTestKeyId2)
.AddKeyId(kHlsTestKeyId3),
HlsInitDataVariant(kHlsTestProvider, kHlsTestContentId,
kHlsTestInvalidKeyId, false)
.AddKeyId(kHlsTestKeyId1)));
TEST_P(HlsParseTest, DISABLED_Parse) {
HlsAttributeVariant param = GetParam();
InitializationData init_data(HLS_INIT_DATA_FORMAT, param.attribute_list_);
if (param.success_) {
@@ -404,17 +555,16 @@ TEST_P(HlsParseTest, Parse) {
EXPECT_FALSE(init_data.IsEmpty());
if (param.key_.compare(HLS_METHOD_ATTRIBUTE) == 0) {
if (param.value_.compare(HLS_METHOD_SAMPLE_AES) == 0) {
EXPECT_EQ(kHlsMethodSampleAes, init_data.hls_data().method);
EXPECT_EQ(kHlsMethodSampleAes, init_data.hls_method());
} else if (param.value_.compare(HLS_METHOD_AES_128) == 0) {
EXPECT_EQ(kHlsMethodAes128, init_data.hls_data().method);
EXPECT_EQ(kHlsMethodAes128, init_data.hls_method());
} else if (param.value_.compare(HLS_METHOD_NONE) == 0) {
EXPECT_EQ(kHlsMethodNone, init_data.hls_data().method);
EXPECT_EQ(kHlsMethodNone, init_data.hls_method());
}
} else {
EXPECT_EQ(kHlsMethodSampleAes, init_data.hls_data().method);
EXPECT_EQ(kHlsMethodSampleAes, init_data.hls_method());
}
EXPECT_EQ(kHlsIvHexValue, b2a_hex(init_data.hls_data().iv));
EXPECT_EQ(kHlsUriValue, init_data.hls_data().uri);
EXPECT_EQ(kHlsIvHexValue, b2a_hex(init_data.hls_iv()));
} else {
EXPECT_TRUE(init_data.is_hls());
EXPECT_TRUE(init_data.IsEmpty());
@@ -429,7 +579,7 @@ INSTANTIATE_TEST_CASE_P(
HLS_KEYFORMAT_ATTRIBUTE, kHlsKeyFormatValueOther,
false),
HlsAttributeVariant(kHlsAttributeListKeyFormatVersionUnsupported,
HLS_KEYFORMAT_VERSION_ATTRIBUTE, "2", false),
HLS_KEYFORMAT_VERSIONS_ATTRIBUTE, "2", false),
HlsAttributeVariant(kHlsAttributeListMethodAes128, HLS_METHOD_ATTRIBUTE,
HLS_METHOD_AES_128, true),
HlsAttributeVariant(kHlsAttributeListMethodNone, HLS_METHOD_ATTRIBUTE,
@@ -439,8 +589,6 @@ INSTANTIATE_TEST_CASE_P(
HlsAttributeVariant(kHlsAttributeListInvalidUri, HLS_URI_ATTRIBUTE,
kHlsTestValueWithEmbeddedQuote, false),
HlsAttributeVariant(kHlsAttributeListInvalidIv, HLS_IV_ATTRIBUTE,
kHlsTestHexValueWithOddBytes, false),
HlsAttributeVariant(kHlsAttributeListInvalidInitData,
HLS_INITDATA_ATTRIBUTE, kHlsTestInvalidHexValue,
false)));
kHlsTestHexValueWithOddBytes, false)));
} // namespace wvcdm