@scrypted/libav 1.0.181 → 1.0.182

package/openh264/docs/doxygen2rst.py

@@ -1,619 +0,0 @@
-from __future__ import print_function
-import re, sys, os, time, glob, errno, tempfile, binascii, subprocess, shutil
-from lxml import etree
-from optparse import OptionParser
-import textwrap
-import string
-
-VERSION = '0.1'
-__all__ = ['DoxyGen2RST']
-LINE_BREAKER = "\n"
-MAX_COLUMN = 80
-
-def is_valid_uuid(uuid_string):
-    uuid4hex = re.compile('[0-9a-f]{32}\Z', re.I)
-    return uuid4hex.match(uuid_string) != None
-
-def get_page(refid):
-    fields = refid.split("_")
-    if(is_valid_uuid(fields[-1][-32:])):
-        return ["_".join(fields[0:-1]), fields[-1]]
-    return [refid, None]
-
-def mkdir_p(path):
-    try:
-        os.makedirs(path)
-    except OSError as exc: # Python >2.5
-        if exc.errno == errno.EEXIST and os.path.isdir(path):
-            pass
-        else:
-            raise
-
-def _glob(path, *exts):
-    path = os.path.join(path, "*") if os.path.isdir(path) else path + "*"
-    return [f for files in [glob.glob(path + ext) for ext in exts] for f in files]
-
-class DoxyGen2RST(object):
-    """
-    Customize the Doxygen XML output into RST format, then it can
-    be translated into all formats with the unified user interface.
-    The Doxygen output itself is too verbose and not hard to be
-    organized for a good documentation.
-    """
-
-    def __init__(self,
-                 src,
-                 dst,
-                 missing_filename = "missing.rst",
-                 is_github = False,
-                 enable_uml = True,
-                 github_ext = ""):
-        self.doxy_output_dir = os.path.join(src, "_doxygen", "xml")
-        self.output_dir = dst
-        self.rst_dir = src
-        self.enable_uml = enable_uml
-        mkdir_p(dst)
-        self.is_github = is_github
-        if(is_github):
-            self.page_ext = github_ext
-            self.anchor_prefix = "wiki-"
-        else:
-            self.anchor_prefix = ""
-            self.page_ext = ".html"
-        self.filter = ["*.rst", "*.rest"]
-        self.re_doxy = "<doxygen2rst\s(\S*)=(\S*)>(.*?)</doxygen2rst>"
-        self.index_root = etree.parse(os.path.join(self.doxy_output_dir, "index.xml")).getroot()
-        self.references = {}
-        self.missed_types_structs = {}
-        self.name_refid_map = {}
-        self.build_references()
-        self.page_references = {}
-        self.missing_filename = missing_filename
-        self.temp_uml_path = os.path.join(tempfile.gettempdir(), "uml_" + binascii.b2a_hex(os.urandom(15)))
-        if os.path.exists(self.temp_uml_path):
-            shutil.rmtree(self.temp_uml_path)
-        os.mkdir(self.temp_uml_path)
-
-    def _find_ref_id(self, kind, name):
-        #print("_find_ref_id, %s - %s" %(kind, name))
-        if(kind == "function"):
-            for comp in self.index_root.iter("member"):
-                if(comp.attrib["kind"].lower() == kind.lower() and
-                   comp.findtext("name").lower() == name.lower()):
-                    return (comp.attrib["refid"])
-            pass
-        else:
-            for comp in self.index_root.iter("compound"):
-                if(comp.attrib["kind"].lower() == kind.lower() and
-                   comp.findtext("name").lower() == name.lower()):
-                   return comp.attrib["refid"]
-        return None
-
-    def strip_title_ref(self, text):
-        table = string.maketrans("","")
-        retstr = text.translate(table, string.punctuation)
-        words = retstr.split()
-        retstr = "-".join(words)
-        return retstr.lower()
-
-    def build_references(self):
-        for file in _glob(self.rst_dir, *self.filter):
-            filename = os.path.basename(file)
-            fin = open(file,'r')
-            content = fin.read()
-            it = re.finditer(self.re_doxy, content, re.DOTALL)
-            for m in it:
-                ref_id = self._find_ref_id(m.groups()[0], m.groups()[1])
-                if(ref_id is None):
-                    #print("Reference is NOT found for: %s=%s" % (m.groups()[0], m.groups()[1]))
-                    continue
-                page_name = os.path.splitext(filename)[0]
-                title_ref = self.strip_title_ref(m.groups()[2])
-                self.references[ref_id] = [m.groups()[0], m.groups()[1], page_name, filename, title_ref]
-                self.name_refid_map[m.groups()[1]] = ref_id
-            fin.close()
-        #print(self.references)
-
-    def call_plantuml(self):
-        if(not self.enable_uml):
-            return
-
-        java_bin = os.path.join(os.environ['JAVA_HOME'], "bin", "java")
-        output_path = os.path.abspath(os.path.join(self.output_dir, "images"))
-        cmds = ["\"" + java_bin + "\"", "-jar", "plantuml.jar", self.temp_uml_path + "/", "-o", output_path]
-        print(" ".join(cmds))
-        os.system(" ".join(cmds))
-        shutil.rmtree(self.temp_uml_path)
-
-    def _build_uml(self, uml_name, content):
-        uml_path = os.path.join(self.temp_uml_path, uml_name + ".txt")
-        fuml = open(uml_path, "w+")
-        fuml.write("@startuml\n")
-        fuml.write(content)
-        fuml.write("\n@enduml\n")
-        fuml.close()
-        return ".. image:: images/" + uml_name + ".png" + LINE_BREAKER
-
-    def _build(self, m):
-        retstr = ""
-        if(m.groups()[0] == "uml"):
-            retstr = self._build_uml(m.groups()[1], m.groups()[2])
-        elif(m.groups()[0] == "link"):
-            link = m.groups()[1] + self.page_ext
-            retstr = ("`%s <%s>`_" % (m.groups()[2], link))
-        else:
-            if(m.groups()[0] != "function"):
-                retstr +=  self._build_title(m.groups()[2])
-            retstr += self.convert_doxy(m.groups()[0], m.groups()[1])
-
-        return retstr
-
-    def generate(self):
-        for file in _glob(self.rst_dir, *self.filter):
-            filename = os.path.basename(file)
-            fin = open(file,'r')
-            input_txt = fin.read()
-            fin.close()
-
-            output_txt = re.sub(self.re_doxy, self._build, input_txt, 0, re.DOTALL)
-            output_txt  += self._build_page_ref_notes()
-
-            fout = open(os.path.join(self.output_dir, filename), 'w+')
-            fout.write(output_txt)
-            fout.close()
-            #print("%s --- %s" %( file, os.path.join(self.output_dir, filename)))
-
-        self._build_missed_types_and_structs()
-        self.call_plantuml()
-
-    def make_para_title(self, title,  indent = 4):
-        retstr = LINE_BREAKER
-        if(title):
-            retstr += "".ljust(indent, " ") + "| **" + title + "**" +  LINE_BREAKER
-        return retstr
-
-    def _build_title(self, title, flag = '=', ref = None):
-        retstr = LINE_BREAKER
-        if(ref):
-            retstr += ".. _ref-" + ref + ":" + LINE_BREAKER + LINE_BREAKER
-        retstr += title + LINE_BREAKER
-        retstr += "".ljust(20, flag) + LINE_BREAKER
-        retstr += LINE_BREAKER
-        return retstr
-
-    def _build_ref(self, node):
-        text = node.text.strip()
-        retstr = ""
-        target = '`' + text + '`'
-        retstr += target + "_ "
-        if target in self.page_references:
-            reflink = self.page_references[target]
-            print("Link already added: %s == %s" % (reflink[0], node.attrib["refid"]))
-            assert(reflink[0] == node.attrib["refid"])
-            pass
-        else:
-            self.page_references[target] = (node.attrib["refid"], node.attrib["kindref"], text)
-
-        return retstr
-
-    def _build_code_block(self, node):
-        retstr = "::" + LINE_BREAKER + LINE_BREAKER
-        for codeline in node.iter("codeline"):
-            retstr += "  "
-            for phrases in codeline.iter("highlight"):
-                if(phrases.text):
-                    retstr += phrases.text.strip()
-                for child in phrases:
-                    if(child.text):
-                        retstr += child.text.strip()
-                    if(child.tag == "sp"):
-                        retstr += " "
-                    if(child.tag == "ref" and child.text):
-                        #escape the reference in the code block
-                        retstr += "" # self._build_ref(child)
-                    if(child.tail):
-                        retstr += child.tail.strip()
-            retstr += LINE_BREAKER
-        return retstr
-
-    def _build_itemlist(self, node):
-        retstr = ""
-        for para in node:
-            if(para.tag != "para"):
-                continue
-            if(para.text):
-                retstr += para.text.strip()
-            for child in para:
-                if(child.tag == "ref" and child.text):
-                    retstr += self._build_ref(child)
-                if(child.tail):
-                    retstr += child.tail.strip()
-
-        return retstr
-
-    def _build_itemizedlist(self, node):
-        retstr = LINE_BREAKER
-        if(node == None):
-            return ""
-        for item in node:
-            if(item.tag != "listitem"):
-                continue
-            retstr += "    - " + self._build_itemlist(item)
-            retstr += LINE_BREAKER
-        return retstr
-
-    def _build_verbatim(self, node):
-        retstr = LINE_BREAKER
-        if(node.text):
-            lines = node.text.splitlines()
-            print(lines[0])
-            m = re.search("{plantuml}\s(\S*)", lines[0])
-            if(m):
-                uml_name = "uml_" + m.groups()[0]
-                retstr += self._build_uml(uml_name, "\n".join(lines[1:]))
-            else:
-                retstr += "::" + LINE_BREAKER + LINE_BREAKER
-                retstr += node.text
-
-        return retstr
-
-    def _build_para(self, para):
-        retstr = ""
-        no_new_line = False
-        if(para.text):
-            retstr += textwrap.fill(para.text.strip(), MAX_COLUMN) + LINE_BREAKER + LINE_BREAKER
-        for child in para:
-            no_new_line = False
-            if(child.tag == "simplesect"):
-                for child_para in child:
-                    if(child.attrib["kind"] == "return"):
-                        return_str = self._build_para(child_para)
-                        retstr += "".ljust(4, " ") + "| Return:" + LINE_BREAKER
-                        for line in return_str.splitlines():
-                            retstr += "".ljust(4, " ") + "| " + line + LINE_BREAKER
-                    elif(child_para.tag == "title" and child_para.text):
-                        lf.make_para_title(child_para.text.strip(), 4)
-                    elif(child_para.tag == "para"): #for @see
-                        retstr += self._build_para(child_para)
-                    elif(child_para.text):
-                        retstr += "".ljust(4, " ") + "| " + child_para.text.strip() + LINE_BREAKER
-            if(child.tag == "preformatted"):
-                retstr += "::" + LINE_BREAKER + LINE_BREAKER
-                if(child.text):
-                    for line in child.text.splitlines():
-                        retstr += "  " + line + LINE_BREAKER
-            if(child.tag == "ref" and child.text):
-                retstr = retstr.rstrip('\n')
-                retstr += " " + self._build_ref(child)
-                no_new_line = True
-            if(child.tag == "programlisting"):
-                retstr += self._build_code_block(child)
-            if(child.tag == "itemizedlist"):
-                retstr += self._build_itemizedlist(child)
-            if(child.tag == "verbatim"):
-                retstr += self._build_verbatim(child)
-            if(not no_new_line):
-                retstr += LINE_BREAKER
-            if(child.tail):
-                retstr += textwrap.fill(child.tail.strip(), MAX_COLUMN) + LINE_BREAKER + LINE_BREAKER
-        return retstr
-
-    def get_text(self, node):
-        retstr = ""
-        if(node == None):
-            return ""
-        for para in node:
-            if(para.tag != "para"):
-                continue
-            retstr += self._build_para(para)
-
-        return retstr
-
-    def _find_text_ref(self, node):
-        retstr = ""
-        if(node.text):
-            retstr += node.text.strip()
-        for child in node:
-            if(child.tag == "ref"):
-                retstr += " " + self._build_ref(child) + " "
-            if(child.tail):
-                retstr += child.tail.strip()
-        return retstr
-
-    def _build_row_breaker(self, columns):
-        retstr = "+"
-        for column in columns:
-            retstr += "".ljust(column, "-") + "+"
-        return retstr + LINE_BREAKER
-
-    def _wrap_cell(self, text, length = 30):
-        newlines = []
-        for line in text.splitlines():
-            newlines.extend(textwrap.wrap(line, length))
-        return newlines
-
-    def _build_row(self, row, columns):
-        retstr = ""
-        row_lines = []
-        max_line = 0
-        for i in range(3):
-            row_lines.append(row[i].splitlines())
-            if(max_line < len(row_lines[i])):
-                max_line = len(row_lines[i])
-
-        for i in range(max_line):
-            for j in range(3):
-                retstr += "|"
-                if(len(row_lines[j]) > i):
-                    retstr += row_lines[j][i]
-                    retstr += "".ljust(columns[j] - len(row_lines[j][i]), " ")
-                else:
-                    retstr += "".ljust(columns[j], " ")
-            retstr += "|" + LINE_BREAKER
-        return retstr
-
-    def _build_table(self, rows):
-        retstr = ""
-        columns = [0, 0, 0]
-        for row in rows:
-            for i in range(3):
-                for rowline in row[i].splitlines():
-                    if(columns[i] < len(rowline) + 2):
-                        columns[i] = len(rowline) + 2
-
-        #columns[0] = 40 if(columns[0] > 40) else columns[0]
-        #columns[1] = 40 if(columns[1] > 40) else columns[1]
-        #columns[2] = MAX_COLUMN - columns[0] - columns[1]
-
-        retstr += self._build_row_breaker(columns)
-        for row in rows:
-            retstr += self._build_row(row, columns)
-            retstr += self._build_row_breaker(columns)
-        return retstr;
-
-    def build_param_list(self, params, paramdescs):
-        retstr = ""
-        param_descriptions = []
-        for desc in paramdescs:
-            param_descriptions.append(desc)
-
-        rows = []
-        rows.append(("Name", "Type", "Descritpion"))
-        for param in params:
-            declname = param.findtext("declname")
-            paramdesc = None
-            for desc in param_descriptions:
-                paramname = desc.findtext("parameternamelist/parametername")
-                if(paramname.lower() == declname.lower()):
-                    paramdesc = desc.find("parameterdescription")
-                    break
-            decltype = self._find_text_ref(param.find("type"))
-            rows.append((declname, decltype, self.get_text(paramdesc)))
-
-        if(len(rows) > 1):
-            retstr += self._build_table(rows)
-        return retstr
-
-    def _build_enum(self, member):
-        enum_id = member.attrib["id"]
-        file, tag = get_page(enum_id)
-        retstr = self._build_title(member.findtext("name"), ref = tag)
-        detail_node = self.get_desc_node(member)
-        if(detail_node is not None):
-            retstr += LINE_BREAKER
-            retstr += self.get_text(detail_node)
-
-        rows = []
-        rows.append(("Name", "Initializer", "Descritpion"))
-        for enumvalue in member.iter("enumvalue"):
-            name = enumvalue.findtext("name")
-            initializer = enumvalue.findtext("initializer")
-            if(not initializer):
-                initializer = ""
-            desc = self.get_text(enumvalue.find("briefdescription"))
-            desc += self.get_text(enumvalue.find("detaileddescription"))
-            if(not desc):
-                desc = ""
-            rows.append((name, initializer, desc))
-
-        if(len(rows) > 1):
-            retstr += self._build_table(rows)
-        return retstr
-
-
-    def _build_struct(self, node):
-        retstr = ""
-        detail_node = self.get_desc_node(node)
-        if(detail_node is not None):
-            retstr += self.get_text(detail_node) + LINE_BREAKER
-        rows = []
-        rows.append(("Name", "Type", "Descritpion"))
-        for member in node.iter("memberdef"):
-            if(member.attrib["kind"] == "variable"):
-                name = member.findtext("name")
-                type = self._find_text_ref(member.find("type"))
-                desc = self.get_text(member.find("briefdescription"))
-                desc += self.get_text(member.find("detaileddescription"))
-                desc += self.get_text(member.find("inbodydescription"))
-                if(not desc):
-                    desc = ""
-                rows.append((name, type, desc))
-
-        if(len(rows) > 1):
-            retstr += self._build_table(rows)
-        return retstr
-
-    def _build_class(self, node):
-        retstr = ""
-
-        for member in node.iter("memberdef"):
-            if(member.attrib["kind"] == "function"):
-                retstr += self.build_function(member)
-        return retstr
-
-    def get_desc_node(self, member):
-        detail_node = member.find("detaileddescription")
-        brief_node = member.find("briefdescription")
-        detail_txt = ""
-        if(detail_node == None and brief_node == None):
-            return None
-
-        if(detail_node is not None):
-            detail_txt = detail_node.findtext("para")
-
-        if(not detail_txt and brief_node != None):
-            detail_txt = brief_node.findtext("para")
-            detail_node = brief_node
-
-        return detail_node
-
-    def build_function(self, member):
-        retstr = ""
-
-        desc_node = self.get_desc_node(member)
-        if(desc_node is None):
-            return ""
-        detail_txt = desc_node.findtext("para")
-        if(not detail_txt or detail_txt.strip() == "{ignore}"):
-            return ""
-
-        func_id = member.attrib["id"]
-        page_id, ref_id = get_page(func_id)
-        retstr += self._build_title(member.findtext("name"), '-', ref = ref_id)
-        retstr += self.get_text(desc_node)
-        retstr += LINE_BREAKER
-        detail_node = member.find("detaileddescription")
-        if(desc_node != detail_node):
-            retstr += self.get_text(detail_node)
-        retstr += self.build_param_list(member.iter("param"), detail_node.iter("parameteritem"))
-        return retstr
-
-    def _build_missed_types_and_structs(self):
-        fout = open(os.path.join(self.output_dir, self.missing_filename), 'w+')
-        fout.write(".. contents:: " + LINE_BREAKER)
-        fout.write("    :local:"  + LINE_BREAKER)
-        fout.write("    :depth: 2" + LINE_BREAKER + LINE_BREAKER)
-
-        footnote = ""
-        while (len(self.missed_types_structs) > 0):
-            for key, value in self.missed_types_structs.iteritems():
-                fout.write(self.covert_item(value[0], key, value[1]))
-                #print(value)
-            self.missed_types_structs = {}
-            footnote += self._build_page_ref_notes()
-
-        fout.write(footnote)
-
-        fout.close()
-
-    def _build_page_ref_notes(self):
-        retstr = LINE_BREAKER
-        #TODO
-        for key, value in self.page_references.iteritems():
-            page, tag = get_page(value[0])
-            m = re.search("_8h_", page)
-            if(m):
-                continue;
-
-            rstname = None
-            anchor = value[2].lower()
-            if not page in self.references:
-                self.missed_types_structs[value[0]] = (page, tag)
-                rstname = os.path.splitext(self.missing_filename)[0]
-            else:
-                rstname = self.references[page][2]
-                anchor = self.references[page][4]
-            #if(tag and not self.is_github):
-            #    anchor = self.anchor_prefix + "ref-" + tag
-            retstr += ".. _" + key + ": " + rstname + self.page_ext + "#" + anchor
-            retstr += LINE_BREAKER + LINE_BREAKER
-        self.page_references = {}
-        return retstr
-
-    def _build_item_by_id(self, node, id):
-        retstr = ""
-        for member in node.iter("memberdef"):
-            if(member.attrib["id"] != id):
-                continue
-            if(member.attrib["kind"] == "enum"):
-                retstr += self._build_enum(member)
-        return retstr
-
-    def covert_item(self, compound, id, tag):
-        xml_path = os.path.join(self.doxy_output_dir, "%s.xml" % compound)
-        print("covert_item: id=%s, name=%s" % (id, xml_path))
-        obj_root = etree.parse(xml_path).getroot()
-        retstr = ""
-        compound = obj_root.find("compounddef")
-        compound_kind = compound.attrib["kind"]
-        if(not tag):
-            retstr += self._build_title(compound.findtext("compoundname"))
-            if(compound_kind == "class"):
-                retstr += self._build_class(compound)
-            elif(compound_kind == "struct"):
-                retstr += self._build_struct(compound)
-        else:
-            retstr += self._build_item_by_id(compound, id)
-
-        return retstr
-
-    def _build_page(self, compound):
-        retstr = ""
-        retstr += self.get_text(compound.find("detaileddescription"))
-        return retstr
-
-    def _build_file(self, compound, type, ref_id, name):
-        retstr = ""
-        for member in compound.iter("memberdef"):
-            if(member.attrib["kind"] == "function" and member.attrib["id"] == ref_id):
-                retstr += self.build_function(member)
-        return retstr
-
-    def convert_doxy(self, type, name):
-        #print(name)
-        file = ref_id = self.name_refid_map[name]
-        dst_kind = type
-        if(type == "function"):
-            file, tag = get_page(ref_id)
-            dst_kind = "file"
-        xml_path = os.path.join(self.doxy_output_dir, "%s.xml" % file)
-        print("convert_doxy: type=%s, name=%s" % (type, xml_path))
-        obj_root = etree.parse(xml_path).getroot()
-        compound = obj_root.find("compounddef")
-        compound_kind = compound.attrib["kind"]
-        assert(dst_kind == compound_kind)
-        retstr = ""
-        if(compound_kind == "class"):
-            retstr += self._build_class(compound)
-        elif(compound_kind == "struct"):
-            retstr += self._build_struct(compound)
-        elif(compound_kind == "page"):
-            retstr += self._build_page(compound)
-        elif(compound_kind == "group"):
-            retstr += self._build_page(compound)
-        elif(compound_kind == "file"):
-            retstr += self._build_file(compound, type, ref_id, name)
-        return retstr
-
-
-if __name__ == '__main__':
-    import argparse
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-g", "--github", action="store_true", help="Render the link in format of github wiki.")
-    parser.add_argument("-e", "--ext", default="", help="extension for github wiki")
-    parser.add_argument("-i", "--input", default="doxygen", help="Input file path of doxygen output and source rst file.")
-    parser.add_argument("-o", "--output", default="wikipage", help="Output converted restructured text files to path.")
-    parser.add_argument("-s", "--struct", default="TypesAndStructures.rest", help="Output of auto generated enum and structures.")
-    parser.add_argument("-u", "--uml", action="store_true", help="Enable UML, you need to download plantuml.jar from Plantuml and put it to here. http://plantuml.sourceforge.net/")
-
-    args = parser.parse_args()
-    ext = ""
-    if(len(args.ext) > 0):
-        ext = ("." + args.ext)
-    agent = DoxyGen2RST(args.input,
-                        args.output,
-                        args.struct,
-                        is_github = True,
-                        enable_uml = args.uml,
-                        github_ext = ext)
-    agent.generate()

package/openh264/gmpopenh264.info

@@ -1,4 +0,0 @@
-Name: gmpopenh264
-Description: GMP Plugin for OpenH264.
-Version: 2.6.0
-APIs: encode-video[h264], decode-video[h264]