2014-02-14 23:21:05 +00:00
|
|
|
// Copyright 2014 Google Inc. All rights reserved.
|
|
|
|
//
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file or at
|
|
|
|
// https://developers.google.com/open-source/licenses/bsd
|
|
|
|
|
2014-10-01 22:10:21 +00:00
|
|
|
#include "packager/mpd/base/mpd_utils.h"
|
2013-11-18 23:39:20 +00:00
|
|
|
|
2014-08-28 18:35:15 +00:00
|
|
|
#include <libxml/tree.h>
|
|
|
|
|
2014-10-01 22:10:21 +00:00
|
|
|
#include "packager/base/logging.h"
|
|
|
|
#include "packager/base/strings/string_number_conversions.h"
|
|
|
|
#include "packager/mpd/base/xml/scoped_xml_ptr.h"
|
2013-11-18 23:39:20 +00:00
|
|
|
|
2014-09-19 20:41:13 +00:00
|
|
|
namespace edash_packager {
|
2015-10-29 20:58:36 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
std::string TextCodecString(
|
|
|
|
const edash_packager::MediaInfo& media_info) {
|
|
|
|
CHECK(media_info.has_text_info());
|
|
|
|
const std::string& format = media_info.text_info().format();
|
|
|
|
// DASH IOP mentions that the codec for ttml in mp4 is stpp.
|
|
|
|
if (format == "ttml" &&
|
|
|
|
(media_info.container_type() == MediaInfo::CONTAINER_MP4)) {
|
|
|
|
return "stpp";
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise codec doesn't need to be specified, e.g. vtt and ttml+xml are
|
|
|
|
// obvious from the mime type.
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|
2013-11-18 23:39:20 +00:00
|
|
|
|
|
|
|
bool HasVODOnlyFields(const MediaInfo& media_info) {
|
|
|
|
return media_info.has_init_range() || media_info.has_index_range() ||
|
2013-12-17 23:08:14 +00:00
|
|
|
media_info.has_media_file_name() ||
|
|
|
|
media_info.has_media_duration_seconds();
|
2013-11-18 23:39:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool HasLiveOnlyFields(const MediaInfo& media_info) {
|
|
|
|
return media_info.has_init_segment_name() ||
|
2013-12-17 23:08:14 +00:00
|
|
|
media_info.has_segment_template() ||
|
|
|
|
media_info.has_segment_duration_seconds();
|
2013-11-18 23:39:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RemoveDuplicateAttributes(
|
|
|
|
ContentProtectionElement* content_protection_element) {
|
|
|
|
DCHECK(content_protection_element);
|
|
|
|
typedef std::map<std::string, std::string> AttributesMap;
|
|
|
|
|
|
|
|
AttributesMap& attributes = content_protection_element->additional_attributes;
|
|
|
|
if (!content_protection_element->value.empty())
|
|
|
|
attributes.erase("value");
|
|
|
|
|
|
|
|
if (!content_protection_element->scheme_id_uri.empty())
|
|
|
|
attributes.erase("schemeIdUri");
|
|
|
|
}
|
|
|
|
|
2016-03-08 19:19:12 +00:00
|
|
|
std::string GetLanguage(const MediaInfo& media_info) {
|
|
|
|
std::string lang;
|
|
|
|
if (media_info.has_audio_info()) {
|
|
|
|
lang = media_info.audio_info().language();
|
|
|
|
} else if (media_info.has_text_info()) {
|
|
|
|
lang = media_info.text_info().language();
|
|
|
|
}
|
|
|
|
return lang;
|
|
|
|
}
|
|
|
|
|
2013-11-18 23:39:20 +00:00
|
|
|
std::string GetCodecs(const MediaInfo& media_info) {
|
2015-10-29 20:58:36 +00:00
|
|
|
CHECK(OnlyOneTrue(media_info.has_video_info(), media_info.has_audio_info(),
|
|
|
|
media_info.has_text_info()));
|
|
|
|
|
2016-01-11 21:36:44 +00:00
|
|
|
if (media_info.has_video_info()) {
|
|
|
|
if (media_info.container_type() == MediaInfo::CONTAINER_WEBM) {
|
|
|
|
std::string codec = media_info.video_info().codec().substr(0, 4);
|
|
|
|
// media_info.video_info().codec() contains new revised codec string
|
|
|
|
// specified by "VPx in ISO BMFF" document, which is not compatible to
|
|
|
|
// old codec strings in WebM. Hack it here before all browsers support
|
|
|
|
// new codec strings.
|
|
|
|
if (codec == "vp08")
|
|
|
|
return "vp8";
|
|
|
|
if (codec == "vp09")
|
|
|
|
return "vp9";
|
|
|
|
}
|
2015-10-29 20:58:36 +00:00
|
|
|
return media_info.video_info().codec();
|
2016-01-11 21:36:44 +00:00
|
|
|
}
|
2015-06-09 23:58:32 +00:00
|
|
|
|
|
|
|
if (media_info.has_audio_info())
|
2015-10-29 20:58:36 +00:00
|
|
|
return media_info.audio_info().codec();
|
|
|
|
|
|
|
|
if (media_info.has_text_info())
|
|
|
|
return TextCodecString(media_info);
|
2013-11-18 23:39:20 +00:00
|
|
|
|
2015-10-29 20:58:36 +00:00
|
|
|
NOTREACHED();
|
2013-11-18 23:39:20 +00:00
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2016-03-08 19:19:12 +00:00
|
|
|
std::string GetBaseCodec(const MediaInfo& media_info) {
|
|
|
|
std::string codec;
|
|
|
|
if (media_info.has_video_info()) {
|
|
|
|
codec = media_info.video_info().codec();
|
|
|
|
} else if (media_info.has_audio_info()) {
|
|
|
|
codec = media_info.audio_info().codec();
|
|
|
|
} else if (media_info.has_text_info()) {
|
|
|
|
codec = media_info.text_info().format();
|
|
|
|
}
|
|
|
|
// Convert, for example, "mp4a.40.2" to simply "mp4a".
|
|
|
|
// "mp4a.40.2" and "mp4a.40.5" can exist in the same AdaptationSet.
|
|
|
|
size_t dot = codec.find('.');
|
|
|
|
if (dot != std::string::npos) {
|
|
|
|
codec.erase(dot);
|
|
|
|
}
|
|
|
|
return codec;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string GetAdaptationSetKey(const MediaInfo& media_info) {
|
|
|
|
std::string key;
|
|
|
|
|
|
|
|
if (media_info.has_video_info()) {
|
|
|
|
key.append("video:");
|
|
|
|
} else if (media_info.has_audio_info()) {
|
|
|
|
key.append("audio:");
|
|
|
|
} else if (media_info.has_text_info()) {
|
|
|
|
key.append(MediaInfo_TextInfo_TextType_Name(media_info.text_info().type()));
|
|
|
|
key.append(":");
|
|
|
|
} else {
|
|
|
|
key.append("unknown:");
|
|
|
|
}
|
|
|
|
|
|
|
|
key.append(MediaInfo_ContainerType_Name(media_info.container_type()));
|
|
|
|
key.append(":");
|
|
|
|
key.append(GetBaseCodec(media_info));
|
|
|
|
key.append(":");
|
|
|
|
key.append(GetLanguage(media_info));
|
|
|
|
|
|
|
|
return key;
|
|
|
|
}
|
|
|
|
|
2014-05-22 02:16:17 +00:00
|
|
|
std::string SecondsToXmlDuration(double seconds) {
|
2014-01-03 00:59:16 +00:00
|
|
|
return "PT" + base::DoubleToString(seconds) + "S";
|
2013-11-18 23:39:20 +00:00
|
|
|
}
|
|
|
|
|
2014-01-03 00:59:16 +00:00
|
|
|
bool GetDurationAttribute(xmlNodePtr node, float* duration) {
|
2013-11-18 23:39:20 +00:00
|
|
|
DCHECK(node);
|
|
|
|
DCHECK(duration);
|
|
|
|
static const char kDuration[] = "duration";
|
2015-11-17 00:06:17 +00:00
|
|
|
xml::scoped_xml_ptr<xmlChar> duration_value(
|
2013-11-18 23:39:20 +00:00
|
|
|
xmlGetProp(node, BAD_CAST kDuration));
|
|
|
|
|
|
|
|
if (!duration_value)
|
|
|
|
return false;
|
|
|
|
|
2014-01-03 00:59:16 +00:00
|
|
|
double duration_double_precision = 0.0;
|
|
|
|
if (!base::StringToDouble(reinterpret_cast<const char*>(duration_value.get()),
|
|
|
|
&duration_double_precision)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*duration = static_cast<float>(duration_double_precision);
|
|
|
|
return true;
|
2013-11-18 23:39:20 +00:00
|
|
|
}
|
|
|
|
|
2014-06-06 08:52:06 +00:00
|
|
|
bool MoreThanOneTrue(bool b1, bool b2, bool b3) {
|
|
|
|
return (b1 && b2) || (b2 && b3) || (b3 && b1);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool AtLeastOneTrue(bool b1, bool b2, bool b3) { return b1 || b2 || b3; }
|
|
|
|
|
|
|
|
bool OnlyOneTrue(bool b1, bool b2, bool b3) {
|
|
|
|
return !MoreThanOneTrue(b1, b2, b3) && AtLeastOneTrue(b1, b2, b3);
|
|
|
|
}
|
|
|
|
|
2015-08-26 20:25:29 +00:00
|
|
|
// Coverts binary data into human readable UUID format.
|
|
|
|
bool HexToUUID(const std::string& data, std::string* uuid_format) {
|
|
|
|
DCHECK(uuid_format);
|
|
|
|
const size_t kExpectedUUIDSize = 16;
|
|
|
|
if (data.size() != kExpectedUUIDSize) {
|
|
|
|
LOG(ERROR) << "UUID size is expected to be " << kExpectedUUIDSize
|
|
|
|
<< " but is " << data.size() << " and the data in hex is "
|
|
|
|
<< base::HexEncode(data.data(), data.size());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
const std::string hex_encoded =
|
2015-07-22 23:40:45 +00:00
|
|
|
base::StringToLowerASCII(base::HexEncode(data.data(), data.size()));
|
2015-08-26 20:25:29 +00:00
|
|
|
DCHECK_EQ(hex_encoded.size(), kExpectedUUIDSize * 2);
|
|
|
|
base::StringPiece all(hex_encoded);
|
|
|
|
// Note UUID has 5 parts separated with dashes.
|
|
|
|
// e.g. 123e4567-e89b-12d3-a456-426655440000
|
|
|
|
// These StringPieces have each part.
|
|
|
|
base::StringPiece first = all.substr(0, 8);
|
|
|
|
base::StringPiece second = all.substr(8, 4);
|
|
|
|
base::StringPiece third = all.substr(12, 4);
|
|
|
|
base::StringPiece fourth = all.substr(16, 4);
|
|
|
|
base::StringPiece fifth = all.substr(20, 12);
|
|
|
|
|
|
|
|
// 32 hexadecimal characters with 4 hyphens.
|
|
|
|
const size_t kHumanReadableUUIDSize = 36;
|
|
|
|
uuid_format->reserve(kHumanReadableUUIDSize);
|
|
|
|
first.CopyToString(uuid_format);
|
|
|
|
uuid_format->append("-");
|
|
|
|
second.AppendToString(uuid_format);
|
|
|
|
uuid_format->append("-");
|
|
|
|
third.AppendToString(uuid_format);
|
|
|
|
uuid_format->append("-");
|
|
|
|
fourth.AppendToString(uuid_format);
|
|
|
|
uuid_format->append("-");
|
|
|
|
fifth.AppendToString(uuid_format);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UpdateContentProtectionPsshHelper(
|
2015-09-24 22:03:52 +00:00
|
|
|
const std::string& drm_uuid,
|
2015-08-26 20:25:29 +00:00
|
|
|
const std::string& pssh,
|
2015-09-24 22:03:52 +00:00
|
|
|
std::list<ContentProtectionElement>* content_protection_elements) {
|
|
|
|
const std::string drm_uuid_schemd_id_uri_form = "urn:uuid:" + drm_uuid;
|
2015-08-26 20:25:29 +00:00
|
|
|
for (std::list<ContentProtectionElement>::iterator protection =
|
2015-09-24 22:03:52 +00:00
|
|
|
content_protection_elements->begin();
|
|
|
|
protection != content_protection_elements->end(); ++protection) {
|
|
|
|
if (protection->scheme_id_uri != drm_uuid_schemd_id_uri_form) {
|
2015-08-26 20:25:29 +00:00
|
|
|
continue;
|
2015-09-24 22:03:52 +00:00
|
|
|
}
|
2015-08-26 20:25:29 +00:00
|
|
|
|
|
|
|
for (std::vector<Element>::iterator subelement =
|
|
|
|
protection->subelements.begin();
|
|
|
|
subelement != protection->subelements.end(); ++subelement) {
|
|
|
|
if (subelement->name == kPsshElementName) {
|
2015-09-24 22:03:52 +00:00
|
|
|
// For now, we want to remove the PSSH element because some players do
|
|
|
|
// not support updating pssh.
|
|
|
|
protection->subelements.erase(subelement);
|
|
|
|
|
|
|
|
// TODO(rkuroiwa): Uncomment this and remove the line above when
|
|
|
|
// shaka-player supports updating PSSH.
|
|
|
|
// subelement->content = pssh;
|
2015-08-26 20:25:29 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2015-09-24 22:03:52 +00:00
|
|
|
|
|
|
|
// Reaching here means <cenc:pssh> does not exist under the
|
|
|
|
// ContentProtection element. Add it.
|
|
|
|
// TODO(rkuroiwa): Uncomment this when shaka-player supports updating PSSH.
|
|
|
|
// Element cenc_pssh;
|
|
|
|
// cenc_pssh.name = kPsshElementName;
|
|
|
|
// cenc_pssh.content = pssh;
|
|
|
|
// protection->subelements.push_back(cenc_pssh);
|
2015-08-26 20:25:29 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-09-24 22:03:52 +00:00
|
|
|
// Reaching here means that ContentProtection for the DRM does not exist.
|
2015-08-26 20:25:29 +00:00
|
|
|
// Add it.
|
|
|
|
ContentProtectionElement content_protection;
|
2015-09-24 22:03:52 +00:00
|
|
|
content_protection.scheme_id_uri = drm_uuid_schemd_id_uri_form;
|
|
|
|
// TODO(rkuroiwa): Uncomment this when shaka-player supports updating PSSH.
|
|
|
|
// Element cenc_pssh;
|
|
|
|
// cenc_pssh.name = kPsshElementName;
|
|
|
|
// cenc_pssh.content = pssh;
|
|
|
|
// content_protection.subelements.push_back(cenc_pssh);
|
|
|
|
content_protection_elements->push_back(content_protection);
|
2015-08-26 20:25:29 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
// Helper function. This works because Representation and AdaptationSet both
|
|
|
|
// have AddContentProtectionElement().
|
|
|
|
template <typename ContentProtectionParent>
|
|
|
|
void AddContentProtectionElementsHelperTemplated(
|
|
|
|
const MediaInfo& media_info,
|
|
|
|
ContentProtectionParent* parent) {
|
|
|
|
DCHECK(parent);
|
|
|
|
if (!media_info.has_protected_content())
|
|
|
|
return;
|
|
|
|
|
|
|
|
const MediaInfo::ProtectedContent& protected_content =
|
|
|
|
media_info.protected_content();
|
|
|
|
|
|
|
|
// DASH MPD spec specifies a default ContentProtection element for ISO BMFF
|
|
|
|
// (MP4) files.
|
|
|
|
const bool is_mp4_container =
|
|
|
|
media_info.container_type() == MediaInfo::CONTAINER_MP4;
|
2016-01-21 00:14:24 +00:00
|
|
|
std::string key_id_uuid_format;
|
|
|
|
if (protected_content.has_default_key_id()) {
|
|
|
|
if (!HexToUUID(protected_content.default_key_id(), &key_id_uuid_format)) {
|
|
|
|
LOG(ERROR) << "Failed to convert default key ID into UUID format.";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-26 20:25:29 +00:00
|
|
|
if (is_mp4_container) {
|
|
|
|
ContentProtectionElement mp4_content_protection;
|
|
|
|
mp4_content_protection.scheme_id_uri = kEncryptedMp4Scheme;
|
|
|
|
mp4_content_protection.value = kEncryptedMp4Value;
|
2016-01-21 00:14:24 +00:00
|
|
|
if (!key_id_uuid_format.empty()) {
|
|
|
|
mp4_content_protection.additional_attributes["cenc:default_KID"] =
|
|
|
|
key_id_uuid_format;
|
2015-08-26 20:25:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
parent->AddContentProtectionElement(mp4_content_protection);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < protected_content.content_protection_entry().size();
|
|
|
|
++i) {
|
|
|
|
const MediaInfo::ProtectedContent::ContentProtectionEntry& entry =
|
|
|
|
protected_content.content_protection_entry(i);
|
|
|
|
if (!entry.has_uuid()) {
|
|
|
|
LOG(WARNING)
|
|
|
|
<< "ContentProtectionEntry was specified but no UUID is set for "
|
|
|
|
<< entry.name_version() << ", skipping.";
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
ContentProtectionElement drm_content_protection;
|
|
|
|
drm_content_protection.scheme_id_uri = "urn:uuid:" + entry.uuid();
|
|
|
|
if (entry.has_name_version())
|
|
|
|
drm_content_protection.value = entry.name_version();
|
|
|
|
|
|
|
|
if (entry.has_pssh()) {
|
|
|
|
std::string base64_encoded_pssh;
|
|
|
|
base::Base64Encode(entry.pssh(), &base64_encoded_pssh);
|
|
|
|
Element cenc_pssh;
|
|
|
|
cenc_pssh.name = kPsshElementName;
|
|
|
|
cenc_pssh.content = base64_encoded_pssh;
|
|
|
|
drm_content_protection.subelements.push_back(cenc_pssh);
|
|
|
|
}
|
|
|
|
|
2016-01-21 00:14:24 +00:00
|
|
|
if (!key_id_uuid_format.empty() && !is_mp4_container) {
|
|
|
|
drm_content_protection.additional_attributes["cenc:default_KID"] =
|
|
|
|
key_id_uuid_format;
|
|
|
|
}
|
|
|
|
|
2015-08-26 20:25:29 +00:00
|
|
|
parent->AddContentProtectionElement(drm_content_protection);
|
|
|
|
}
|
|
|
|
|
|
|
|
LOG_IF(WARNING, protected_content.content_protection_entry().size() == 0)
|
|
|
|
<< "The media is encrypted but no content protection specified.";
|
|
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
void AddContentProtectionElements(const MediaInfo& media_info,
|
|
|
|
Representation* parent) {
|
|
|
|
AddContentProtectionElementsHelperTemplated(media_info, parent);
|
|
|
|
}
|
|
|
|
|
|
|
|
void AddContentProtectionElements(const MediaInfo& media_info,
|
|
|
|
AdaptationSet* parent) {
|
|
|
|
AddContentProtectionElementsHelperTemplated(media_info, parent);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-09-19 20:41:13 +00:00
|
|
|
} // namespace edash_packager
|