476 lines
16 KiB
C++
476 lines
16 KiB
C++
// 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
|
|
|
|
#include "packager/mpd/base/xml/xml_node.h"
|
|
|
|
#include <gflags/gflags.h>
|
|
|
|
#include <limits>
|
|
#include <set>
|
|
|
|
#include "packager/base/logging.h"
|
|
#include "packager/base/macros.h"
|
|
#include "packager/base/strings/string_number_conversions.h"
|
|
#include "packager/base/sys_byteorder.h"
|
|
#include "packager/mpd/base/media_info.pb.h"
|
|
#include "packager/mpd/base/mpd_utils.h"
|
|
#include "packager/mpd/base/segment_info.h"
|
|
|
|
DEFINE_bool(segment_template_constant_duration,
|
|
false,
|
|
"Generates SegmentTemplate@duration if all segments except the "
|
|
"last one has the same duration if this flag is set to true.");
|
|
|
|
namespace shaka {
|
|
|
|
using xml::XmlNode;
|
|
typedef MediaInfo::AudioInfo AudioInfo;
|
|
typedef MediaInfo::VideoInfo VideoInfo;
|
|
|
|
namespace {
|
|
const char kEC3Codec[] = "ec-3";
|
|
|
|
std::string RangeToString(const Range& range) {
|
|
return base::Uint64ToString(range.begin()) + "-" +
|
|
base::Uint64ToString(range.end());
|
|
}
|
|
|
|
// Check if segments are continuous and all segments except the last one are of
|
|
// the same duration.
|
|
bool IsTimelineConstantDuration(const std::list<SegmentInfo>& segment_infos,
|
|
uint32_t start_number) {
|
|
if (!FLAGS_segment_template_constant_duration)
|
|
return false;
|
|
|
|
DCHECK(!segment_infos.empty());
|
|
if (segment_infos.size() > 2)
|
|
return false;
|
|
|
|
const SegmentInfo& first_segment = segment_infos.front();
|
|
if (first_segment.start_time != first_segment.duration * (start_number - 1))
|
|
return false;
|
|
|
|
if (segment_infos.size() == 1)
|
|
return true;
|
|
|
|
const SegmentInfo& last_segment = segment_infos.back();
|
|
if (last_segment.repeat != 0)
|
|
return false;
|
|
|
|
const int64_t expected_last_segment_start_time =
|
|
first_segment.start_time +
|
|
first_segment.duration * (first_segment.repeat + 1);
|
|
return expected_last_segment_start_time == last_segment.start_time;
|
|
}
|
|
|
|
bool PopulateSegmentTimeline(const std::list<SegmentInfo>& segment_infos,
|
|
XmlNode* segment_timeline) {
|
|
for (const SegmentInfo& segment_info : segment_infos) {
|
|
XmlNode s_element("S");
|
|
s_element.SetIntegerAttribute("t", segment_info.start_time);
|
|
s_element.SetIntegerAttribute("d", segment_info.duration);
|
|
if (segment_info.repeat > 0)
|
|
s_element.SetIntegerAttribute("r", segment_info.repeat);
|
|
|
|
CHECK(segment_timeline->AddChild(s_element.PassScopedPtr()));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CollectNamespaceFromName(const std::string& name,
|
|
std::set<std::string>* namespaces) {
|
|
const size_t pos = name.find(':');
|
|
if (pos != std::string::npos)
|
|
namespaces->insert(name.substr(0, pos));
|
|
}
|
|
|
|
void TraverseAttrsAndCollectNamespaces(const xmlAttr* attr,
|
|
std::set<std::string>* namespaces) {
|
|
for (const xmlAttr* cur_attr = attr; cur_attr; cur_attr = cur_attr->next) {
|
|
CollectNamespaceFromName(reinterpret_cast<const char*>(cur_attr->name),
|
|
namespaces);
|
|
}
|
|
}
|
|
|
|
void TraverseNodesAndCollectNamespaces(const xmlNode* node,
|
|
std::set<std::string>* namespaces) {
|
|
for (const xmlNode* cur_node = node; cur_node; cur_node = cur_node->next) {
|
|
CollectNamespaceFromName(reinterpret_cast<const char*>(cur_node->name),
|
|
namespaces);
|
|
|
|
TraverseNodesAndCollectNamespaces(cur_node->children, namespaces);
|
|
TraverseAttrsAndCollectNamespaces(cur_node->properties, namespaces);
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
namespace xml {
|
|
|
|
XmlNode::XmlNode(const char* name) : node_(xmlNewNode(NULL, BAD_CAST name)) {
|
|
DCHECK(name);
|
|
DCHECK(node_);
|
|
}
|
|
|
|
XmlNode::~XmlNode() {}
|
|
|
|
bool XmlNode::AddChild(scoped_xml_ptr<xmlNode> child) {
|
|
DCHECK(node_);
|
|
DCHECK(child);
|
|
if (!xmlAddChild(node_.get(), child.get()))
|
|
return false;
|
|
|
|
// Reaching here means the ownership of |child| transfered to |node_|.
|
|
// Release the pointer so that it doesn't get destructed in this scope.
|
|
ignore_result(child.release());
|
|
return true;
|
|
}
|
|
|
|
bool XmlNode::AddElements(const std::vector<Element>& elements) {
|
|
for (size_t element_index = 0; element_index < elements.size();
|
|
++element_index) {
|
|
const Element& child_element = elements[element_index];
|
|
XmlNode child_node(child_element.name.c_str());
|
|
for (std::map<std::string, std::string>::const_iterator attribute_it =
|
|
child_element.attributes.begin();
|
|
attribute_it != child_element.attributes.end(); ++attribute_it) {
|
|
child_node.SetStringAttribute(attribute_it->first.c_str(),
|
|
attribute_it->second);
|
|
}
|
|
|
|
// Note that somehow |SetContent| needs to be called before |AddElements|
|
|
// otherwise the added children will be overwritten by the content.
|
|
child_node.SetContent(child_element.content);
|
|
|
|
// Recursively set children for the child.
|
|
if (!child_node.AddElements(child_element.subelements))
|
|
return false;
|
|
|
|
if (!xmlAddChild(node_.get(), child_node.GetRawPtr())) {
|
|
LOG(ERROR) << "Failed to set child " << child_element.name
|
|
<< " to parent element "
|
|
<< reinterpret_cast<const char*>(node_->name);
|
|
return false;
|
|
}
|
|
// Reaching here means the ownership of |child_node| transfered to |node_|.
|
|
// Release the pointer so that it doesn't get destructed in this scope.
|
|
ignore_result(child_node.Release());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void XmlNode::SetStringAttribute(const char* attribute_name,
|
|
const std::string& attribute) {
|
|
DCHECK(node_);
|
|
DCHECK(attribute_name);
|
|
xmlSetProp(node_.get(), BAD_CAST attribute_name, BAD_CAST attribute.c_str());
|
|
}
|
|
|
|
void XmlNode::SetIntegerAttribute(const char* attribute_name, uint64_t number) {
|
|
DCHECK(node_);
|
|
DCHECK(attribute_name);
|
|
xmlSetProp(node_.get(),
|
|
BAD_CAST attribute_name,
|
|
BAD_CAST (base::Uint64ToString(number).c_str()));
|
|
}
|
|
|
|
void XmlNode::SetFloatingPointAttribute(const char* attribute_name,
|
|
double number) {
|
|
DCHECK(node_);
|
|
DCHECK(attribute_name);
|
|
xmlSetProp(node_.get(), BAD_CAST attribute_name,
|
|
BAD_CAST(base::DoubleToString(number).c_str()));
|
|
}
|
|
|
|
void XmlNode::SetId(uint32_t id) {
|
|
SetIntegerAttribute("id", id);
|
|
}
|
|
|
|
void XmlNode::SetContent(const std::string& content) {
|
|
DCHECK(node_);
|
|
xmlNodeSetContent(node_.get(), BAD_CAST content.c_str());
|
|
}
|
|
|
|
std::set<std::string> XmlNode::ExtractReferencedNamespaces() {
|
|
std::set<std::string> namespaces;
|
|
TraverseNodesAndCollectNamespaces(node_.get(), &namespaces);
|
|
return namespaces;
|
|
}
|
|
|
|
scoped_xml_ptr<xmlNode> XmlNode::PassScopedPtr() {
|
|
DVLOG(2) << "Passing node_.";
|
|
DCHECK(node_);
|
|
return std::move(node_);
|
|
}
|
|
|
|
xmlNodePtr XmlNode::Release() {
|
|
DVLOG(2) << "Releasing node_.";
|
|
DCHECK(node_);
|
|
return node_.release();
|
|
}
|
|
|
|
xmlNodePtr XmlNode::GetRawPtr() {
|
|
return node_.get();
|
|
}
|
|
|
|
RepresentationBaseXmlNode::RepresentationBaseXmlNode(const char* name)
|
|
: XmlNode(name) {}
|
|
RepresentationBaseXmlNode::~RepresentationBaseXmlNode() {}
|
|
|
|
bool RepresentationBaseXmlNode::AddContentProtectionElements(
|
|
const std::list<ContentProtectionElement>& content_protection_elements) {
|
|
std::list<ContentProtectionElement>::const_iterator content_protection_it =
|
|
content_protection_elements.begin();
|
|
for (; content_protection_it != content_protection_elements.end();
|
|
++content_protection_it) {
|
|
if (!AddContentProtectionElement(*content_protection_it))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void RepresentationBaseXmlNode::AddSupplementalProperty(
|
|
const std::string& scheme_id_uri,
|
|
const std::string& value) {
|
|
AddDescriptor("SupplementalProperty", scheme_id_uri, value);
|
|
}
|
|
|
|
void RepresentationBaseXmlNode::AddEssentialProperty(
|
|
const std::string& scheme_id_uri,
|
|
const std::string& value) {
|
|
AddDescriptor("EssentialProperty", scheme_id_uri, value);
|
|
}
|
|
|
|
bool RepresentationBaseXmlNode::AddDescriptor(
|
|
const std::string& descriptor_name,
|
|
const std::string& scheme_id_uri,
|
|
const std::string& value) {
|
|
XmlNode descriptor(descriptor_name.c_str());
|
|
descriptor.SetStringAttribute("schemeIdUri", scheme_id_uri);
|
|
if (!value.empty())
|
|
descriptor.SetStringAttribute("value", value);
|
|
return AddChild(descriptor.PassScopedPtr());
|
|
}
|
|
|
|
bool RepresentationBaseXmlNode::AddContentProtectionElement(
|
|
const ContentProtectionElement& content_protection_element) {
|
|
XmlNode content_protection_node("ContentProtection");
|
|
|
|
// @value is an optional attribute.
|
|
if (!content_protection_element.value.empty()) {
|
|
content_protection_node.SetStringAttribute(
|
|
"value", content_protection_element.value);
|
|
}
|
|
content_protection_node.SetStringAttribute(
|
|
"schemeIdUri", content_protection_element.scheme_id_uri);
|
|
|
|
typedef std::map<std::string, std::string> AttributesMapType;
|
|
const AttributesMapType& additional_attributes =
|
|
content_protection_element.additional_attributes;
|
|
|
|
AttributesMapType::const_iterator attributes_it =
|
|
additional_attributes.begin();
|
|
for (; attributes_it != additional_attributes.end(); ++attributes_it) {
|
|
content_protection_node.SetStringAttribute(attributes_it->first.c_str(),
|
|
attributes_it->second);
|
|
}
|
|
|
|
if (!content_protection_node.AddElements(
|
|
content_protection_element.subelements)) {
|
|
return false;
|
|
}
|
|
return AddChild(content_protection_node.PassScopedPtr());
|
|
}
|
|
|
|
AdaptationSetXmlNode::AdaptationSetXmlNode()
|
|
: RepresentationBaseXmlNode("AdaptationSet") {}
|
|
AdaptationSetXmlNode::~AdaptationSetXmlNode() {}
|
|
|
|
void AdaptationSetXmlNode::AddAccessibilityElement(
|
|
const std::string& scheme_id_uri,
|
|
const std::string& value) {
|
|
AddDescriptor("Accessibility", scheme_id_uri, value);
|
|
}
|
|
|
|
void AdaptationSetXmlNode::AddRoleElement(const std::string& scheme_id_uri,
|
|
const std::string& value) {
|
|
AddDescriptor("Role", scheme_id_uri, value);
|
|
}
|
|
|
|
RepresentationXmlNode::RepresentationXmlNode()
|
|
: RepresentationBaseXmlNode("Representation") {}
|
|
RepresentationXmlNode::~RepresentationXmlNode() {}
|
|
|
|
bool RepresentationXmlNode::AddVideoInfo(const VideoInfo& video_info,
|
|
bool set_width,
|
|
bool set_height,
|
|
bool set_frame_rate) {
|
|
if (!video_info.has_width() || !video_info.has_height()) {
|
|
LOG(ERROR) << "Missing width or height for adding a video info.";
|
|
return false;
|
|
}
|
|
|
|
if (video_info.has_pixel_width() && video_info.has_pixel_height()) {
|
|
SetStringAttribute("sar", base::IntToString(video_info.pixel_width()) +
|
|
":" +
|
|
base::IntToString(video_info.pixel_height()));
|
|
}
|
|
|
|
if (set_width)
|
|
SetIntegerAttribute("width", video_info.width());
|
|
if (set_height)
|
|
SetIntegerAttribute("height", video_info.height());
|
|
if (set_frame_rate) {
|
|
SetStringAttribute("frameRate",
|
|
base::IntToString(video_info.time_scale()) + "/" +
|
|
base::IntToString(video_info.frame_duration()));
|
|
}
|
|
|
|
if (video_info.has_playback_rate()) {
|
|
SetStringAttribute("maxPlayoutRate",
|
|
base::IntToString(video_info.playback_rate()));
|
|
// Since the trick play stream contains only key frames, there is no coding
|
|
// dependency on the main stream. Simply set the codingDependency to false.
|
|
// TODO(hmchen): propagate this attribute up to the AdaptationSet, since
|
|
// all are set to false.
|
|
SetStringAttribute("codingDependency", "false");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool RepresentationXmlNode::AddAudioInfo(const AudioInfo& audio_info) {
|
|
if (!AddAudioChannelInfo(audio_info))
|
|
return false;
|
|
|
|
AddAudioSamplingRateInfo(audio_info);
|
|
return true;
|
|
}
|
|
|
|
bool RepresentationXmlNode::AddVODOnlyInfo(const MediaInfo& media_info) {
|
|
if (media_info.has_media_file_url()) {
|
|
XmlNode base_url("BaseURL");
|
|
base_url.SetContent(media_info.media_file_url());
|
|
|
|
if (!AddChild(base_url.PassScopedPtr()))
|
|
return false;
|
|
}
|
|
|
|
const bool need_segment_base = media_info.has_index_range() ||
|
|
media_info.has_init_range() ||
|
|
media_info.has_reference_time_scale();
|
|
|
|
if (need_segment_base) {
|
|
XmlNode segment_base("SegmentBase");
|
|
if (media_info.has_index_range()) {
|
|
segment_base.SetStringAttribute("indexRange",
|
|
RangeToString(media_info.index_range()));
|
|
}
|
|
|
|
if (media_info.has_reference_time_scale()) {
|
|
segment_base.SetIntegerAttribute("timescale",
|
|
media_info.reference_time_scale());
|
|
}
|
|
|
|
if (media_info.has_presentation_time_offset()) {
|
|
segment_base.SetIntegerAttribute("presentationTimeOffset",
|
|
media_info.presentation_time_offset());
|
|
}
|
|
|
|
if (media_info.has_init_range()) {
|
|
XmlNode initialization("Initialization");
|
|
initialization.SetStringAttribute("range",
|
|
RangeToString(media_info.init_range()));
|
|
|
|
if (!segment_base.AddChild(initialization.PassScopedPtr()))
|
|
return false;
|
|
}
|
|
|
|
if (!AddChild(segment_base.PassScopedPtr()))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RepresentationXmlNode::AddLiveOnlyInfo(
|
|
const MediaInfo& media_info,
|
|
const std::list<SegmentInfo>& segment_infos,
|
|
uint32_t start_number) {
|
|
XmlNode segment_template("SegmentTemplate");
|
|
if (media_info.has_reference_time_scale()) {
|
|
segment_template.SetIntegerAttribute("timescale",
|
|
media_info.reference_time_scale());
|
|
}
|
|
|
|
if (media_info.has_presentation_time_offset()) {
|
|
segment_template.SetIntegerAttribute("presentationTimeOffset",
|
|
media_info.presentation_time_offset());
|
|
}
|
|
|
|
if (media_info.has_init_segment_url()) {
|
|
segment_template.SetStringAttribute("initialization",
|
|
media_info.init_segment_url());
|
|
}
|
|
|
|
if (media_info.has_segment_template_url()) {
|
|
segment_template.SetStringAttribute("media",
|
|
media_info.segment_template_url());
|
|
segment_template.SetIntegerAttribute("startNumber", start_number);
|
|
}
|
|
|
|
if (!segment_infos.empty()) {
|
|
// Don't use SegmentTimeline if all segments except the last one are of
|
|
// the same duration.
|
|
if (IsTimelineConstantDuration(segment_infos, start_number)) {
|
|
segment_template.SetIntegerAttribute("duration",
|
|
segment_infos.front().duration);
|
|
} else {
|
|
XmlNode segment_timeline("SegmentTimeline");
|
|
if (!PopulateSegmentTimeline(segment_infos, &segment_timeline) ||
|
|
!segment_template.AddChild(segment_timeline.PassScopedPtr())) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return AddChild(segment_template.PassScopedPtr());
|
|
}
|
|
|
|
bool RepresentationXmlNode::AddAudioChannelInfo(const AudioInfo& audio_info) {
|
|
std::string audio_channel_config_scheme;
|
|
std::string audio_channel_config_value;
|
|
|
|
if (audio_info.codec() == kEC3Codec) {
|
|
// Convert EC3 channel map into string of hexadecimal digits. Spec: DASH-IF
|
|
// Interoperability Points v3.0 9.2.1.2.
|
|
const uint16_t ec3_channel_map =
|
|
base::HostToNet16(audio_info.codec_specific_data().ec3_channel_map());
|
|
audio_channel_config_value =
|
|
base::HexEncode(&ec3_channel_map, sizeof(ec3_channel_map));
|
|
audio_channel_config_scheme =
|
|
"tag:dolby.com,2014:dash:audio_channel_configuration:2011";
|
|
} else {
|
|
audio_channel_config_value = base::UintToString(audio_info.num_channels());
|
|
audio_channel_config_scheme =
|
|
"urn:mpeg:dash:23003:3:audio_channel_configuration:2011";
|
|
}
|
|
|
|
return AddDescriptor("AudioChannelConfiguration", audio_channel_config_scheme,
|
|
audio_channel_config_value);
|
|
}
|
|
|
|
// MPD expects one number for sampling frequency, or if it is a range it should
|
|
// be space separated.
|
|
void RepresentationXmlNode::AddAudioSamplingRateInfo(
|
|
const AudioInfo& audio_info) {
|
|
if (audio_info.has_sampling_frequency())
|
|
SetIntegerAttribute("audioSamplingRate", audio_info.sampling_frequency());
|
|
}
|
|
|
|
} // namespace xml
|
|
} // namespace shaka
|