[vlc-commits] [Git][videolan/vlc][master] 5 commits: demux: adaptive: remove unused xml node code
Steve Lhomme (@robUx4)
gitlab at videolan.org
Wed Apr 3 19:50:22 UTC 2024
Steve Lhomme pushed to branch master at VideoLAN / VLC
Commits:
fb83bc0f by François Cartegnie at 2024-04-03T19:10:26+00:00
demux: adaptive: remove unused xml node code
- - - - -
f06b9059 by François Cartegnie at 2024-04-03T19:10:26+00:00
demux: adaptive: remove unneeded vtable destructor
- - - - -
ba9e7df6 by François Cartegnie at 2024-04-03T19:10:26+00:00
demux: adaptive: add shared namespaces
- - - - -
a65d6118 by François Cartegnie at 2024-04-03T19:10:26+00:00
demux: adaptive: split and remove attributes map
- - - - -
f8b95a03 by François Cartegnie at 2024-04-03T19:10:26+00:00
demux: adaptive: match namespaces
- - - - -
15 changed files:
- modules/demux/Makefile.am
- modules/demux/adaptive/xml/DOMHelper.cpp
- modules/demux/adaptive/xml/DOMHelper.h
- modules/demux/adaptive/xml/DOMParser.cpp
- modules/demux/adaptive/xml/DOMParser.h
- + modules/demux/adaptive/xml/Namespaces.cpp
- + modules/demux/adaptive/xml/Namespaces.hpp
- modules/demux/adaptive/xml/Node.cpp
- modules/demux/adaptive/xml/Node.h
- modules/demux/dash/DASHManager.cpp
- modules/demux/dash/mpd/IsoffMainParser.cpp
- modules/demux/dash/mpd/IsoffMainParser.h
- modules/demux/meson.build
- modules/demux/smooth/playlist/Manifest.hpp
- modules/demux/smooth/playlist/SmoothParser.cpp
Changes:
=====================================
modules/demux/Makefile.am
=====================================
@@ -414,6 +414,8 @@ libvlc_adaptive_la_SOURCES = \
demux/adaptive/xml/DOMHelper.h \
demux/adaptive/xml/DOMParser.cpp \
demux/adaptive/xml/DOMParser.h \
+ demux/adaptive/xml/Namespaces.cpp \
+ demux/adaptive/xml/Namespaces.hpp \
demux/adaptive/xml/Node.cpp \
demux/adaptive/xml/Node.h
libvlc_adaptive_la_SOURCES += \
=====================================
modules/demux/adaptive/xml/DOMHelper.cpp
=====================================
@@ -29,53 +29,56 @@
using namespace adaptive::xml;
-std::vector<Node *> DOMHelper::getElementByTagName (Node *root, const std::string& name, bool selfContain)
+std::vector<Node *> DOMHelper::getElementByTagName(Node *root, const std::string& name,
+ const std::string& ns, bool selfContain)
{
std::vector<Node *> elements;
for(size_t i = 0; i < root->getSubNodes().size(); i++)
{
- getElementsByTagName(root->getSubNodes().at(i), name, &elements, selfContain);
+ getElementsByTagName(root->getSubNodes().at(i), name, ns, &elements, selfContain);
}
return elements;
}
-std::vector<Node *> DOMHelper::getChildElementByTagName (Node *root, const std::string& name)
+std::vector<Node *> DOMHelper::getChildElementByTagName(Node *root, const std::string& name,
+ const std::string& ns)
{
std::vector<Node *> elements;
for(size_t i = 0; i < root->getSubNodes().size(); i++)
{
- if( root->getSubNodes().at(i)->getName() == name )
+ if(root->getSubNodes().at(i)->matches(name, ns))
elements.push_back(root->getSubNodes().at(i));
}
return elements;
}
-void DOMHelper::getElementsByTagName (Node *root, const std::string& name, std::vector<Node*> *elements, bool selfContain)
+void DOMHelper::getElementsByTagName(Node *root, const std::string& name, const std::string &ns,
+ std::vector<Node*> *elements, bool selfContain)
{
- if(!selfContain && !root->getName().compare(name))
+ if(!selfContain && root->matches(name, ns))
{
elements->push_back(root);
return;
}
- if(!root->getName().compare(name))
+ if(root->matches(name, ns))
elements->push_back(root);
for(size_t i = 0; i < root->getSubNodes().size(); i++)
{
- getElementsByTagName(root->getSubNodes().at(i), name, elements, selfContain);
+ getElementsByTagName(root->getSubNodes().at(i), name, ns, elements, selfContain);
}
}
-Node* DOMHelper::getFirstChildElementByName( Node *root, const std::string &name )
+Node* DOMHelper::getFirstChildElementByName(Node *root, const std::string &name, const std::string& ns)
{
for(size_t i = 0; i < root->getSubNodes().size(); i++)
{
- if( root->getSubNodes().at( i )->getName() == name )
+ if(root->getSubNodes().at(i)->matches(name, ns))
return root->getSubNodes().at( i );
}
return nullptr;
=====================================
modules/demux/adaptive/xml/DOMHelper.h
=====================================
@@ -37,12 +37,16 @@ namespace adaptive
class DOMHelper
{
public:
- static std::vector<Node *> getElementByTagName (Node *root, const std::string& name, bool selfContain);
- static std::vector<Node *> getChildElementByTagName (Node *root, const std::string& name);
- static Node* getFirstChildElementByName( Node *root, const std::string& name );
+ static std::vector<Node *> getElementByTagName (Node *root, const std::string& name,
+ const std::string& ns, bool selfContain);
+ static std::vector<Node *> getChildElementByTagName (Node *root, const std::string& name,
+ const std::string& ns);
+ static Node* getFirstChildElementByName(Node *root, const std::string& name,
+ const std::string& ns);
private:
- static void getElementsByTagName(Node *root, const std::string& name, std::vector<Node *> *elements, bool selfContain);
+ static void getElementsByTagName(Node *root, const std::string& name, const std::string &ns,
+ std::vector<Node *> *elements, bool selfContain);
};
}
}
=====================================
modules/demux/adaptive/xml/DOMParser.cpp
=====================================
@@ -29,6 +29,7 @@
#include <vector>
#include <stack>
+#include <cstring>
#include <vlc_xml.h>
using namespace adaptive::xml;
@@ -92,25 +93,28 @@ bool DOMParser::reset(stream_t *s)
Node* DOMParser::processNode(bool b_strict)
{
- const char *data;
+ const char *data, *ns;
int type;
std::stack<Node *> lifo;
- while( (type = xml_ReaderNextNode(vlc_reader, &data)) > 0 )
+ while( (type = xml_ReaderNextNodeNS(vlc_reader, &data, &ns)) > 0 )
{
switch(type)
{
case XML_READER_STARTELEM:
{
+ Namespaces::Ptr ptr = nss.registerNamespace(ns);
bool empty = xml_ReaderIsEmptyElement(vlc_reader);
- Node *node = new (std::nothrow) Node();
+ const char *unprefixed = std::strchr(data, ':');
+ data = unprefixed ? unprefixed + 1 : data;
+ auto name = std::make_unique<std::string>(data);
+ Node *node = new (std::nothrow) Node(std::move(name), ptr);
if(node)
{
if(!lifo.empty())
lifo.top()->addSubNode(node);
lifo.push(node);
- node->setName(std::string(data));
addAttributesToNode(node);
}
@@ -160,12 +164,14 @@ void DOMParser::addAttributesToNode (Node *node)
{
const char *attrValue;
const char *attrName;
+ const char *ns;
- while((attrName = xml_ReaderNextAttr(this->vlc_reader, &attrValue)) != nullptr)
+ while((attrName = xml_ReaderNextAttrNS(this->vlc_reader, &attrValue, &ns)) != nullptr)
{
+ Namespaces::Ptr ptr = nss.registerNamespace(ns ? ns : "");
std::string key = attrName;
std::string value = attrValue;
- node->addAttribute(key, value);
+ node->addAttribute(key, ptr, value);
}
}
void DOMParser::print (Node *node, int offset)
@@ -175,10 +181,10 @@ void DOMParser::print (Node *node, int offset)
msg_Dbg(this->stream, "%s", node->getName().c_str());
- std::vector<std::string> keys = node->getAttributeKeys();
+ const Node::Attributes &attributes = node->getAttributes();
- for(size_t i = 0; i < keys.size(); i++)
- msg_Dbg(this->stream, " %s=%s", keys.at(i).c_str(), node->getAttributeValue(keys.at(i)).c_str());
+ for(auto attr : attributes)
+ msg_Dbg(this->stream, " %s=%s", attr.name.c_str(), attr.value.c_str());
msg_Dbg(this->stream, "\n");
=====================================
modules/demux/adaptive/xml/DOMParser.h
=====================================
@@ -47,6 +47,7 @@ namespace adaptive
void print ();
private:
+ Namespaces nss;
Node *root;
stream_t *stream;
=====================================
modules/demux/adaptive/xml/Namespaces.cpp
=====================================
@@ -0,0 +1,53 @@
+/*
+ * Namespaces.cpp
+ *****************************************************************************
+ * Copyright (C) 2024 - VideoLabs, VideoLAN and VLC Authors
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "Namespaces.hpp"
+
+#include <algorithm>
+#include <cstring>
+
+using namespace adaptive::xml;
+
+Namespaces::Ptr Namespaces::registerNamespace(const char *ns)
+{
+ if(ns == nullptr)
+ ns = "";
+ Ptr ptr = getNamespace(ns);
+ if(ptr == nullptr)
+ ptr = std::make_shared<Entry>(std::string(ns));
+ return ptr;
+}
+
+Namespaces::Ptr Namespaces::getNamespace(const std::string &ns)
+{
+ auto it = std::find_if(nss.begin(), nss.end(),
+ [ns](Ptr &e){ return *e == ns; });
+ return it != nss.end() ? *it : nullptr;
+}
+
+Namespaces::Ptr Namespaces::getNamespace(const char *ns)
+{
+ auto it = std::find_if(nss.begin(), nss.end(),
+ [ns](Ptr &e){ return !std::strcmp(e.get()->c_str(), ns); });
+ return it != nss.end() ? *it : nullptr;
+}
=====================================
modules/demux/adaptive/xml/Namespaces.hpp
=====================================
@@ -0,0 +1,48 @@
+/*
+ * Namespaces.hpp
+ *****************************************************************************
+ * Copyright (C) 2024 - VideoLabs, VideoLAN and VLC Authors
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+#ifndef NAMESPACES_H_
+#define NAMESPACES_H_
+
+#include <vector>
+#include <string>
+#include <memory>
+
+namespace adaptive
+{
+ namespace xml
+ {
+ class Namespaces
+ {
+ public:
+ using Entry = std::string;
+ using Ptr = std::shared_ptr<Entry>;
+
+ Namespaces() = default;
+ Ptr registerNamespace(const char *);
+ Ptr getNamespace(const std::string &);
+ Ptr getNamespace(const char *);
+
+ private:
+ std::vector<Ptr> nss;
+ };
+ }
+}
+
+#endif /* NAMESPACES_HPP_ */
=====================================
modules/demux/adaptive/xml/Node.cpp
=====================================
@@ -28,6 +28,7 @@
#include "Node.h"
#include <cassert>
+#include <algorithm>
#include <vlc_common.h>
#include <vlc_xml.h>
@@ -35,10 +36,17 @@ using namespace adaptive::xml;
const std::string Node::EmptyString = "";
-Node::Node() :
- type( -1 )
+bool Node::Attribute::matches(const std::string &name, const std::string &ns) const
{
+ return *this->ns == ns && this->name == name;
}
+
+Node::Node(std::unique_ptr<std::string> name, Namespaces::Ptr ns)
+{
+ this->name = std::move(name);
+ this->ns = ns;
+}
+
Node::~Node ()
{
for(size_t i = 0; i < this->subNodes.size(); i++)
@@ -55,43 +63,51 @@ void Node::addSubNode (Node *node)
}
const std::string& Node::getName () const
{
- return this->name;
+ return *name;
}
-void Node::setName (const std::string& name)
+
+const std::string & Node::getNamespace() const
{
- this->name = name;
+ if(ns != nullptr)
+ return *ns;
+ return EmptyString;
}
-bool Node::hasAttribute (const std::string& name) const
+bool Node::hasAttribute(const std::string& name) const
{
- if(this->attributes.find(name) != this->attributes.end())
- return true;
-
- return false;
+ return hasAttribute(name, EmptyString);
}
-const std::string& Node::getAttributeValue (const std::string& key) const
-{
- std::map<std::string, std::string>::const_iterator it = this->attributes.find( key );
- if ( it != this->attributes.end() )
- return it->second;
- return EmptyString;
+bool Node::hasAttribute(const std::string& name, const std::string &ns) const
+{
+ auto it = std::find_if(attributes.cbegin(),attributes.cend(),
+ [name, ns](const struct Attribute &a)
+ {return a.name == name && ns == *a.ns;});
+ return it != attributes.cend();
}
-void Node::addAttribute ( const std::string& key, const std::string& value)
+const std::string& Node::getAttributeValue(const std::string& key) const
{
- this->attributes[key] = value;
+ return getAttributeValue(key, EmptyString);
}
-std::vector<std::string> Node::getAttributeKeys () const
+
+const std::string& Node::getAttributeValue(const std::string& key, const std::string &ns) const
{
- std::vector<std::string> keys;
- std::map<std::string, std::string>::const_iterator it;
+ auto it = std::find_if(attributes.cbegin(),attributes.cend(),
+ [key, ns](const struct Attribute &a)
+ {return a.name == key && ns == *a.ns;});
+ if (it != attributes.cend())
+ return (*it).value;
+ return EmptyString;
+}
- for(it = this->attributes.begin(); it != this->attributes.end(); ++it)
- {
- keys.push_back(it->first);
- }
- return keys;
+void Node::addAttribute(const std::string& key, Namespaces::Ptr ns, const std::string& value)
+{
+ struct Attribute attr;
+ attr.name = key;
+ attr.ns = ns;
+ attr.value = value;
+ attributes.push_back(std::move(attr));
}
const std::string& Node::getText () const
@@ -104,32 +120,12 @@ void Node::setText(const std::string &text)
this->text = text;
}
-const std::map<std::string,std::string>& Node::getAttributes () const
+const Node::Attributes& Node::getAttributes() const
{
return this->attributes;
}
-int Node::getType() const
-{
- return this->type;
-}
-
-void Node::setType(int type)
-{
- this->type = type;
-}
-
-std::vector<std::string> Node::toString(int indent) const
+bool Node::matches(const std::string &name, const std::string &ns) const
{
- std::vector<std::string> ret;
- std::string text(indent, ' ');
- text.append(getName());
- ret.push_back(text);
- std::vector<Node *>::const_iterator l;
- for(l = subNodes.begin(); l < subNodes.end(); ++l)
- {
- std::vector<std::string> sub = (*l)->toString(indent + 1);
- ret.insert(ret.end(), sub.begin(), sub.end());
- }
- return ret;
+ return *this->ns == ns && *this->name == name;
}
=====================================
modules/demux/adaptive/xml/Node.h
=====================================
@@ -25,9 +25,10 @@
#ifndef NODE_H_
#define NODE_H_
+#include "Namespaces.hpp"
+
#include <vector>
#include <string>
-#include <map>
namespace adaptive
{
@@ -36,32 +37,42 @@ namespace adaptive
class Node
{
public:
- Node ();
- virtual ~Node ();
+ class Attribute
+ {
+ public:
+ std::string name;
+ std::string value;
+ Namespaces::Ptr ns;
+ bool matches(const std::string &name, const std::string &ns) const;
+ };
+
+ using Attributes = std::vector<struct Attribute>;
+
+ Node () = delete;
+ Node(std::unique_ptr<std::string>, Namespaces::Ptr);
+ ~Node ();
const std::vector<Node *>& getSubNodes () const;
void addSubNode (Node *node);
const std::string& getName () const;
- void setName (const std::string& name);
- bool hasAttribute (const std::string& name) const;
- void addAttribute (const std::string& key, const std::string& value);
+ const std::string& getNamespace () const;
+ bool hasAttribute (const std::string& key) const;
+ bool hasAttribute (const std::string& key, const std::string &ns) const;
+ void addAttribute (const std::string& key, Namespaces::Ptr, const std::string& value);
const std::string& getAttributeValue (const std::string& key) const;
- std::vector<std::string> getAttributeKeys () const;
+ const std::string& getAttributeValue (const std::string& key, const std::string &ns) const;
const std::string& getText () const;
void setText( const std::string &text );
- const std::map<std::string, std::string>& getAttributes () const;
- int getType() const;
- void setType( int type );
- std::vector<std::string> toString(int) const;
+ const Attributes& getAttributes () const;
+ bool matches(const std::string &name, const std::string &ns) const;
private:
static const std::string EmptyString;
std::vector<Node *> subNodes;
- std::map<std::string, std::string> attributes;
- std::string name;
+ Attributes attributes;
+ std::unique_ptr<std::string> name;
+ Namespaces::Ptr ns;
std::string text;
- int type;
-
};
}
}
=====================================
modules/demux/dash/DASHManager.cpp
=====================================
@@ -168,23 +168,16 @@ int DASHManager::doControl(int i_query, va_list args)
bool DASHManager::isDASH(xml::Node *root)
{
static const std::string namespaces[] = {
- "urn:mpeg:mpegB:schema:DASH:MPD:DIS2011",
- "urn:mpeg:schema:dash:mpd:2011",
+ "urn:mpeg:dash:schema:mpd:2011",
"urn:mpeg:DASH:schema:MPD:2011",
- "urn:mpeg:mpegB:schema:DASH:MPD:DIS2011",
"urn:mpeg:schema:dash:mpd:2011",
- "urn:mpeg:DASH:schema:MPD:2011",
+ "urn:mpeg:mpegB:schema:DASH:MPD:DIS2011",
};
- if(root->getName() != "MPD")
- return false;
-
- const std::string &ns = root->getAttributeValue("xmlns");
for( size_t i=0; i<ARRAY_SIZE(namespaces); i++ )
- {
- if ( adaptive::Helper::ifind(ns, namespaces[i]) )
+ if(root->matches("MPD", namespaces[i]))
return true;
- }
+
return false;
}
=====================================
modules/demux/dash/mpd/IsoffMainParser.cpp
=====================================
@@ -83,7 +83,7 @@ static void parseAvailability(MPD *mpd, Node *node, T *s)
void IsoffMainParser::parseMPDBaseUrl(MPD *mpd, Node *root)
{
- std::vector<Node *> baseUrls = DOMHelper::getChildElementByTagName(root, "BaseURL");
+ std::vector<Node *> baseUrls = DOMHelper::getChildElementByTagName(root, "BaseURL", getDASHNamespace());
for(size_t i = 0; i < baseUrls.size(); i++)
mpd->addBaseUrl(baseUrls.at(i)->getText());
@@ -97,7 +97,7 @@ MPD * IsoffMainParser::parse()
if(mpd)
{
parseMPDAttributes(mpd, root);
- parseProgramInformation(DOMHelper::getFirstChildElementByName(root, "ProgramInformation"), mpd);
+ parseProgramInformation(DOMHelper::getFirstChildElementByName(root, "ProgramInformation", getDASHNamespace()), mpd);
parseMPDBaseUrl(mpd, root);
parsePeriods(mpd, root);
mpd->addAttribute(new StartnumberAttr(1));
@@ -108,56 +108,60 @@ MPD * IsoffMainParser::parse()
void IsoffMainParser::parseMPDAttributes (MPD *mpd, xml::Node *node)
{
- const std::map<std::string, std::string> & attr = node->getAttributes();
+ const Node::Attributes& attributes = node->getAttributes();
- std::map<std::string, std::string>::const_iterator it;
+ mpd->b_needsUpdates = false;
- it = attr.find("mediaPresentationDuration");
- if(it != attr.end())
- mpd->duration.Set(IsoTime(it->second));
-
- it = attr.find("minBufferTime");
- if(it != attr.end())
- mpd->setMinBuffering(IsoTime(it->second));
-
- it = attr.find("minimumUpdatePeriod");
- if(it != attr.end())
+ for(auto attr: attributes)
{
- mpd->b_needsUpdates = true;
- vlc_tick_t minupdate = IsoTime(it->second);
- if(minupdate > 0)
- mpd->minUpdatePeriod.Set(minupdate);
- }
- else mpd->b_needsUpdates = false;
-
- it = attr.find("maxSegmentDuration");
- if(it != attr.end())
- mpd->maxSegmentDuration.Set(IsoTime(it->second));
-
- it = attr.find("type");
- if(it != attr.end())
- mpd->setType(it->second);
-
- it = attr.find("availabilityStartTime");
- if(it != attr.end())
- mpd->availabilityStartTime.Set(UTCTime(it->second).mtime());
-
- it = attr.find("availabilityEndTime");
- if(it != attr.end())
- mpd->availabilityEndTime.Set(UTCTime(it->second).mtime());
-
- it = attr.find("timeShiftBufferDepth");
- if(it != attr.end())
- mpd->timeShiftBufferDepth.Set(IsoTime(it->second));
+ if(*attr.ns != NS_DASH)
+ continue;
- it = attr.find("suggestedPresentationDelay");
- if(it != attr.end())
- mpd->suggestedPresentationDelay.Set(IsoTime(it->second));
+ if(attr.name == "mediaPresentationDuration")
+ {
+ mpd->duration.Set(IsoTime(attr.value));
+ }
+ else if(attr.name == "minBufferTime")
+ {
+ mpd->setMinBuffering(IsoTime(attr.value));
+ }
+ else if(attr.name == "minimumUpdatePeriod")
+ {
+ mpd->b_needsUpdates = true;
+ vlc_tick_t minupdate = IsoTime(attr.value);
+ if(minupdate > 0)
+ mpd->minUpdatePeriod.Set(minupdate);
+ }
+ else if(attr.name == "maxSegmentDuration")
+ {
+ mpd->maxSegmentDuration.Set(IsoTime(attr.value));
+ }
+ else if(attr.name == "type")
+ {
+ mpd->setType(attr.value);
+ }
+ else if(attr.name == "availabilityStartTime")
+ {
+ mpd->availabilityStartTime.Set(UTCTime(attr.value).mtime());
+ }
+ else if(attr.name == "availabilityEndTime")
+ {
+ mpd->availabilityEndTime.Set(UTCTime(attr.value).mtime());
+ }
+ else if(attr.name == "timeShiftBufferDepth")
+ {
+ mpd->timeShiftBufferDepth.Set(IsoTime(attr.value));
+ }
+ else if(attr.name == "suggestedPresentationDelay")
+ {
+ mpd->suggestedPresentationDelay.Set(IsoTime(attr.value));
+ }
+ }
}
void IsoffMainParser::parsePeriods(MPD *mpd, Node *root)
{
- std::vector<Node *> periods = DOMHelper::getElementByTagName(root, "Period", false);
+ std::vector<Node *> periods = DOMHelper::getElementByTagName(root, "Period", getDASHNamespace(), false);
std::vector<Node *>::const_iterator it;
uint64_t nextid = 0;
@@ -171,7 +175,7 @@ void IsoffMainParser::parsePeriods(MPD *mpd, Node *root)
period->startTime.Set(IsoTime((*it)->getAttributeValue("start")));
if((*it)->hasAttribute("duration"))
period->duration.Set(IsoTime((*it)->getAttributeValue("duration")));
- std::vector<Node *> baseUrls = DOMHelper::getChildElementByTagName(*it, "BaseURL");
+ std::vector<Node *> baseUrls = DOMHelper::getChildElementByTagName(*it, "BaseURL", getDASHNamespace());
if(!baseUrls.empty())
{
period->baseUrl.Set( new Url( baseUrls.front()->getText() ) );
@@ -187,7 +191,7 @@ void IsoffMainParser::parseSegmentBaseType(MPD *, Node *node,
AbstractSegmentBaseType *base,
SegmentInformation *parent)
{
- parseInitSegment(DOMHelper::getFirstChildElementByName(node, "Initialization"), base, parent);
+ parseInitSegment(DOMHelper::getFirstChildElementByName(node, "Initialization", getDASHNamespace()), base, parent);
if(node->hasAttribute("indexRange"))
{
@@ -225,7 +229,7 @@ void IsoffMainParser::parseMultipleSegmentBaseType(MPD *mpd, Node *node,
if(node->hasAttribute("startNumber"))
base->addAttribute(new StartnumberAttr(Integer<uint64_t>(node->getAttributeValue("startNumber"))));
- parseTimeline(DOMHelper::getFirstChildElementByName(node, "SegmentTimeline"), base);
+ parseTimeline(DOMHelper::getFirstChildElementByName(node, "SegmentTimeline", getDASHNamespace()), base);
}
size_t IsoffMainParser::parseSegmentTemplate(MPD *mpd, Node *templateNode, SegmentInformation *info)
@@ -268,9 +272,9 @@ size_t IsoffMainParser::parseSegmentInformation(MPD *mpd, Node *node,
SegmentInformation *info, uint64_t *nextid)
{
size_t total = 0;
- total += parseSegmentBase(mpd, DOMHelper::getFirstChildElementByName(node, "SegmentBase"), info);
- total += parseSegmentList(mpd, DOMHelper::getFirstChildElementByName(node, "SegmentList"), info);
- total += parseSegmentTemplate(mpd, DOMHelper::getFirstChildElementByName(node, "SegmentTemplate" ), info);
+ total += parseSegmentBase(mpd, DOMHelper::getFirstChildElementByName(node, "SegmentBase", getDASHNamespace()), info);
+ total += parseSegmentList(mpd, DOMHelper::getFirstChildElementByName(node, "SegmentList", getDASHNamespace()), info);
+ total += parseSegmentTemplate(mpd, DOMHelper::getFirstChildElementByName(node, "SegmentTemplate", getDASHNamespace()), info);
if(node->hasAttribute("timescale"))
info->addAttribute(new TimescaleAttr(Timescale(Integer<uint64_t>(node->getAttributeValue("timescale")))));
@@ -286,7 +290,7 @@ size_t IsoffMainParser::parseSegmentInformation(MPD *mpd, Node *node,
void IsoffMainParser::parseAdaptationSets (MPD *mpd, Node *periodNode, BasePeriod *period)
{
- std::vector<Node *> adaptationSets = DOMHelper::getElementByTagName(periodNode, "AdaptationSet", false);
+ std::vector<Node *> adaptationSets = DOMHelper::getElementByTagName(periodNode, "AdaptationSet", getDASHNamespace(), false);
std::vector<Node *>::const_iterator it;
uint64_t nextid = 0;
@@ -307,14 +311,14 @@ void IsoffMainParser::parseAdaptationSets (MPD *mpd, Node *periodNode, BaseP
if((*it)->hasAttribute("segmentAlignment"))
adaptationSet->setSegmentAligned((*it)->getAttributeValue("segmentAlignment") == "true");
- Node *baseUrl = DOMHelper::getFirstChildElementByName((*it), "BaseURL");
+ Node *baseUrl = DOMHelper::getFirstChildElementByName((*it), "BaseURL", getDASHNamespace());
if(baseUrl)
{
parseAvailability<AdaptationSet>(mpd, baseUrl, adaptationSet);
adaptationSet->baseUrl.Set(new Url(baseUrl->getText()));
}
- Node *role = DOMHelper::getFirstChildElementByName((*it), "Role");
+ Node *role = DOMHelper::getFirstChildElementByName((*it), "Role", getDASHNamespace());
if(role && role->hasAttribute("schemeIdUri") && role->hasAttribute("value"))
{
const std::string &uri = role->getAttributeValue("schemeIdUri");
@@ -370,7 +374,7 @@ void IsoffMainParser::parseCommonAttributesElements(Node *node,
void IsoffMainParser::parseRepresentations (MPD *mpd, Node *adaptationSetNode, AdaptationSet *adaptationSet)
{
- std::vector<Node *> representations = DOMHelper::getElementByTagName(adaptationSetNode, "Representation", false);
+ std::vector<Node *> representations = DOMHelper::getElementByTagName(adaptationSetNode, "Representation", getDASHNamespace(), false);
uint64_t nextid = 0;
for(size_t i = 0; i < representations.size(); i++)
@@ -378,7 +382,7 @@ void IsoffMainParser::parseRepresentations (MPD *mpd, Node *adaptationSetNode
Representation *currentRepresentation = new Representation(adaptationSet);
Node *repNode = representations.at(i);
- std::vector<Node *> baseUrls = DOMHelper::getChildElementByTagName(repNode, "BaseURL");
+ std::vector<Node *> baseUrls = DOMHelper::getChildElementByTagName(repNode, "BaseURL", getDASHNamespace());
if(!baseUrls.empty())
{
currentRepresentation->baseUrl.Set(new Url(baseUrls.front()->getText()));
@@ -439,7 +443,7 @@ size_t IsoffMainParser::parseSegmentList(MPD *mpd, Node * segListNode, SegmentIn
size_t total = 0;
if(segListNode)
{
- std::vector<Node *> segments = DOMHelper::getElementByTagName(segListNode, "SegmentURL", false);
+ std::vector<Node *> segments = DOMHelper::getElementByTagName(segListNode, "SegmentURL", getDASHNamespace(), false);
SegmentList *list;
if((list = new (std::nothrow) SegmentList(info)))
{
@@ -523,7 +527,7 @@ void IsoffMainParser::parseTimeline(Node *node, AbstractMultipleSegmentBaseType
SegmentTimeline *timeline = new (std::nothrow) SegmentTimeline(base);
if(timeline)
{
- std::vector<Node *> elements = DOMHelper::getElementByTagName(node, "S", false);
+ std::vector<Node *> elements = DOMHelper::getElementByTagName(node, "S", getDASHNamespace(), false);
std::vector<Node *>::const_iterator it;
for(it = elements.begin(); it != elements.end(); ++it)
{
@@ -561,15 +565,15 @@ void IsoffMainParser::parseProgramInformation(Node * node, MPD *mpd)
ProgramInformation *info = new (std::nothrow) ProgramInformation();
if (info)
{
- Node *child = DOMHelper::getFirstChildElementByName(node, "Title");
+ Node *child = DOMHelper::getFirstChildElementByName(node, "Title", getDASHNamespace());
if(child)
info->setTitle(child->getText());
- child = DOMHelper::getFirstChildElementByName(node, "Source");
+ child = DOMHelper::getFirstChildElementByName(node, "Source", getDASHNamespace());
if(child)
info->setSource(child->getText());
- child = DOMHelper::getFirstChildElementByName(node, "Copyright");
+ child = DOMHelper::getFirstChildElementByName(node, "Copyright", getDASHNamespace());
if(child)
info->setCopyright(child->getText());
@@ -602,3 +606,8 @@ Profile IsoffMainParser::getProfile() const
return res;
}
+
+const std::string & IsoffMainParser::getDASHNamespace() const
+{
+ return root->getNamespace();
+}
=====================================
modules/demux/dash/mpd/IsoffMainParser.h
=====================================
@@ -61,6 +61,8 @@ namespace dash
using namespace adaptive::playlist;
using namespace adaptive;
+ static const std::string NS_DASH("urn:mpeg:dash:schema:mpd:2011");
+
class IsoffMainParser
{
public:
@@ -71,6 +73,7 @@ namespace dash
private:
mpd::Profile getProfile () const;
+ const std::string & getDASHNamespace() const;
void parseMPDBaseUrl (MPD *, xml::Node *);
void parseMPDAttributes (MPD *, xml::Node *);
void parseAdaptationSets (MPD *, xml::Node *periodNode, BasePeriod *period);
=====================================
modules/demux/meson.build
=====================================
@@ -571,6 +571,8 @@ vlc_modules += {
'adaptive/xml/DOMHelper.h',
'adaptive/xml/DOMParser.cpp',
'adaptive/xml/DOMParser.h',
+ 'adaptive/xml/Namespaces.cpp',
+ 'adaptive/xml/Namespaces.hpp',
'adaptive/xml/Node.cpp',
'adaptive/xml/Node.h',
=====================================
modules/demux/smooth/playlist/Manifest.hpp
=====================================
@@ -28,6 +28,8 @@ namespace smooth
{
using namespace adaptive::playlist;
+ static std::string NS_SMOOTH = "";
+
class Manifest : public BasePlaylist
{
friend class ManifestParser;
=====================================
modules/demux/smooth/playlist/SmoothParser.cpp
=====================================
@@ -58,7 +58,7 @@ static SegmentTimeline *createTimeline(Node *streamIndexNode)
SegmentTimeline *timeline = new (std::nothrow) SegmentTimeline(nullptr);
if(timeline)
{
- std::vector<Node *> chunks = DOMHelper::getElementByTagName(streamIndexNode, "c", true);
+ std::vector<Node *> chunks = DOMHelper::getElementByTagName(streamIndexNode, "c", NS_SMOOTH, true);
std::vector<Node *>::const_iterator it;
struct
@@ -253,7 +253,7 @@ static void ParseStreamIndex(BasePeriod *period, Node *streamIndexNode, unsigned
unsigned nextid = 1;
const std::string &type = streamIndexNode->getAttributeValue("Type");
- std::vector<Node *> qualLevels = DOMHelper::getElementByTagName(streamIndexNode, "QualityLevel", true);
+ std::vector<Node *> qualLevels = DOMHelper::getElementByTagName(streamIndexNode, "QualityLevel", NS_SMOOTH, true);
std::vector<Node *>::const_iterator it;
for(it = qualLevels.begin(); it != qualLevels.end(); ++it)
ParseQualityLevel(adaptSet, *it, type, nextid++, id, timescale);
@@ -302,7 +302,7 @@ Manifest * ManifestParser::parse()
{
period->duration.Set(manifest->duration.Get());
unsigned nextid = 1;
- std::vector<Node *> streamIndexes = DOMHelper::getElementByTagName(root, "StreamIndex", true);
+ std::vector<Node *> streamIndexes = DOMHelper::getElementByTagName(root, "StreamIndex", NS_SMOOTH, true);
std::vector<Node *>::const_iterator it;
for(it = streamIndexes.begin(); it != streamIndexes.end(); ++it)
ParseStreamIndex(period, *it, nextid++);
View it on GitLab: https://code.videolan.org/videolan/vlc/-/compare/e4d39d64c54cca9707e3c28ca12c749688f1fdb2...f8b95a0383001c74fe9da51cde0614153186b9f7
--
View it on GitLab: https://code.videolan.org/videolan/vlc/-/compare/e4d39d64c54cca9707e3c28ca12c749688f1fdb2...f8b95a0383001c74fe9da51cde0614153186b9f7
You're receiving this email because of your account on code.videolan.org.
VideoLAN code repository instance
More information about the vlc-commits
mailing list