home *** CD-ROM | disk | FTP | other *** search
/ PC Professionell 2006 June / PCpro_2006_06.ISO / files / freeware / openvip.exe / {app} / conv.py < prev    next >
Encoding:
Python Source  |  2004-01-10  |  12.6 KB  |  340 lines
  1. #
  2. # This file is part of OpenVIP (http://openvip.sourceforge.net)
  3. #
  4. # Copyright (C) 2002-2003
  5. # Michal Dvorak, Jiri Sedlar, Antonin Slavik, Vaclav Slavik, Jozef Smizansky
  6. #
  7. # This program is licensed under GNU General Public License version 2;
  8. # see file COPYING in the top level directory for details.
  9. #
  10. # $Id: conv.py,v 1.15 2004/01/10 12:21:20 vaclavslavik Exp $
  11. #
  12.  
  13. import xml.dom.minidom
  14. import model
  15. import string
  16. import openvip
  17. import globals
  18.  
  19. class ParsingError(Exception):
  20.     def __init__(self, msg):
  21.         self.msg = msg
  22.     def __str__(self):
  23.         return self.msg
  24.  
  25. DOCTYPE_PUBLIC_ID = "-//OPENVIP//DTD Timeline Format V1.0//EN"
  26. DOCTYPE_SYSTEM_ID = "http://openvip.sourceforge.net/dtds/openvip-timeline.dtd"        
  27. NEAR = 0.1
  28. #main functions
  29.  
  30. def dom_to_data(dom):
  31.         "creates fills and returns model.Timeline object from given dom"
  32.         dom.normalize()
  33.         data = model.Timeline()
  34.         if dom.firstChild.nodeName == "timeline":
  35.                 try:
  36.                         storeNetwork(dom.getElementsByTagName("timeline")[0],data)
  37.                 except KeyError, e:
  38.                         raise ParsingError("%s"% e)
  39.         checkInput(data)
  40.         return data
  41.  
  42.  
  43. def data_to_dom(data,xmlns,version):
  44.         "Extracts data to dom object"
  45.         #dom = xml.dom.minidom.Document()
  46.         import conv2
  47.         dom = conv2.myDocument()
  48.  
  49.         doctype = xml.dom.minidom.DocumentType("timeline") 
  50.         doctype.publicId = DOCTYPE_PUBLIC_ID
  51.         doctype.systemId = DOCTYPE_SYSTEM_ID
  52.         dom.doctype = doctype
  53.         
  54.         el = dom.createElement("timeline")
  55.         el.setAttribute("version",version)
  56.         el.setAttribute("xmlns",xmlns)
  57.         
  58.         extractObjects(data,el)
  59.         extractTransitions(data,el)
  60.         extractGroups(data,el)
  61.  
  62.         dom.appendChild(el)
  63.  
  64.         return dom
  65.  
  66. #auxiliary functions
  67.  
  68.  
  69. def checkDTD(data,e):
  70.         import xmlhelpers
  71.         import tempfile
  72.         import os
  73.         
  74.         fname = tempfile.mktemp("conv2_tmp") 
  75.         f=open(fname, 'w')
  76.         dom2 = data_to_dom(data,"http://openvip.sourceforge.net/timeline-format","1.0")
  77.         f.write(dom2.toxml())
  78.         f.close()
  79.         dom2.unlink()
  80.         valid = xmlhelpers.validate(fname)
  81.         os.remove(fname)
  82.         if valid != 1: e.msg = "Document does not match to it's DTD"
  83.         return valid == 1
  84.  
  85. def checkFiles(data,e):
  86.         import os
  87.         for o in data.objects:
  88.                 if not os.path.exists(o.src_spec["filename"]): 
  89.                         e.msg = o.src_spec["filename"] + " does not exist"
  90.                         return False
  91.         return True
  92.  
  93. def checkObjectLengths(data,e):
  94.         #lib = openvip.Library()
  95.         for o in data.objects:
  96.                 if abs((o.time_to - o.time_from) - (o.src_to - o.src_from))>NEAR\
  97.                                 and o.src_to != 0:
  98.                         e.msg = """Object length differs from source specification
  99.                         (object.src_from, object.src_to)"""
  100.                         return False
  101.                 i = globals.get_file_info(o.src_spec["filename"])
  102.                 length = o.time_to - o.time_from
  103.                                         
  104.                 if o.track[0] == "V":
  105.                         for v in i.video_streams:
  106.                                 if o.src_from == 0 and o.src_to==0 and\
  107.                                                 abs(length - float(v.length)/v.fps)>NEAR:
  108.                                         e.msg = "Wrong length of object %s"%o.id
  109.                                         return False
  110.                                 if o.src_to > float(v.length)/v.fps:
  111.                                         e.msg = "Wrong length of object %s"%o.id
  112.                                         return False
  113.                 else :
  114.                         for a in i.audio_streams:
  115.                                 if o.src_from == 0 and o.src_to==0 and\
  116.                                                 abs(length - float(a.length)/a.sample_rate)>NEAR:
  117.                                         e.msg = "Wrong length of object %s"%o.id
  118.                                         return False
  119.                                 if o.src_to > float(a.length)/a.sample_rate:
  120.                                         e.msg = "Wrong length of object %s"%o.id
  121.                                         return False
  122.         return True
  123.  
  124. def checkObjectsConflicts(data,e):
  125.         return True
  126.  
  127. def checkInput(data):
  128.         e = model.Error("")
  129.         if not checkDTD(data,e):
  130.                 raise e
  131.                 return False
  132.         if not checkFiles(data,e):
  133.                 raise e
  134.                 return False
  135.         if not checkObjectLengths(data,e):
  136.                 raise e
  137.                 return False
  138.         if not checkObjectsConflicts(data,e):
  139.                 raise e
  140.                 return False
  141.         return True
  142.  
  143.  
  144. def storeNetwork(node,data):
  145.         for child in node.childNodes:
  146.                 if   child.nodeName == "object":
  147.                         storeObject(child,data)
  148.                 elif child.nodeName == "transition_object":
  149.                         storeTransitionObject(child,data)
  150.         for child in node.childNodes:
  151.                 if child.nodeName == "group":
  152.                         storeGroup(child,data)                        
  153.         
  154. def storePosition(node,object):
  155.         "If current Position attributes exist they are stored into object"
  156.         a = node.attributes._attrs
  157.         object.time_from = string.atof(node.attributes["time_from"].value)
  158.         object.time_to = string.atof(node.attributes["time_to"].value)
  159.         object.track = node.attributes["track"].value
  160.         if a.has_key("direction"):        
  161.                 object.direction = node.attributes["direction"].value
  162.         
  163. def storeParams(node,dir):
  164.         for child in node.childNodes:
  165.                 if child.nodeName == "param":
  166.                         dir[child.attributes["name"].value] = \
  167.                         child.firstChild.nodeValue.strip()
  168.                         
  169. def storeSource(node,object):
  170.         object.src_from = string.atof(node.attributes["src_from"].value)
  171.         object.src_to = string.atof(node.attributes["src_to"].value)
  172.         for child in node.childNodes:
  173.                 if child.nodeName == "channel":
  174.                         object.src_channel = child.attributes["name"].value
  175.                 if child.nodeName == "params":
  176.                         storeParams(child,object.src_spec)
  177.  
  178. def storeFilters(node,object):
  179.         for child in node.childNodes:
  180.                 if child.nodeName == "filter":
  181.                         filter = model.Filter()
  182.                         a = child.attributes._attrs
  183.                         filter.name = child.attributes["name"].value
  184.                         filter.active = True
  185.                         
  186.                         if a.has_key("active") and\
  187.                                 string.lower(child.attributes["active"].value)=="false":
  188.                                         filter.active = False
  189.                         for child2 in child.childNodes:
  190.                                 if child2.nodeName == "params":
  191.                                         storeParams(child2,filter.params)
  192.                         object.filters.append(filter)
  193.  
  194. def storeObject(node,data):
  195.         object = model.Object()
  196.         object.id = node.attributes["id"].value
  197.         for child in node.childNodes:
  198.                 if child.nodeName == "position":
  199.                         storePosition(child,object)
  200.                 if child.nodeName == "source":
  201.                         storeSource(child,object)
  202.                 if child.nodeName == "filters":
  203.                         storeFilters(child,object)
  204.                 
  205.         data.objects.append(object)
  206.         
  207. def storeTransitionObject(node,data):
  208.         trans = model.Transition()
  209.         trans.id = node.attributes["id"].value
  210.         for child in node.childNodes:
  211.                 if child.nodeName == "transition":
  212.                         trans.name =  child.attributes["name"].value
  213.                         for child2 in child.childNodes:
  214.                                 if child2.nodeName == "params":
  215.                                         storeParams(child2,trans.params)
  216.                 if child.nodeName == "position":
  217.                         storePosition(child,trans)
  218.                 
  219.         data.transitions.append(trans)
  220.  
  221. def storeGroup(node,data):
  222.         group = model.Group()
  223.         group.id =  node.attributes["id"].value
  224.         for child in node.childNodes:
  225.                 if child.nodeName == "item":
  226.                         o_ref = None
  227.                         for o in data.objects + data.transitions:
  228.                                 if o.id == child.attributes["ref"].value:
  229.                                         o_ref = o
  230.                         if o_ref == None:
  231.                                 raise KeyError()
  232.                         group.objects.append(o_ref)
  233.         data.groups.append(group)
  234.  
  235.  
  236. def extractObjects(data,node):
  237.         dom = xml.dom.minidom.Document()
  238.         for object in data.objects:
  239.                 el = dom.createElement("object")
  240.                 el.setAttribute("id",object.id)
  241.                 pos = extractPosition(object)
  242.                 el.appendChild(pos)
  243.                 src = dom.createElement("source")
  244.                 src.setAttribute("src_from",str(object.src_from))
  245.                 src.setAttribute("src_to",str(object.src_to))
  246.                 channel = dom.createElement("channel")
  247.                 channel.setAttribute("name",object.src_channel)
  248.                 src.appendChild(channel)
  249.                 params = extractParams(object.src_spec)
  250.                 src.appendChild(params)
  251.                 el.appendChild(src)
  252.                 filters =  dom.createElement("filters")
  253.                 extractFilters(object.filters,filters)
  254.                 if 0 < len(filters.childNodes):
  255.                         el.appendChild(filters)
  256.                 node.appendChild(el)
  257.         dom.unlink()
  258.         
  259. def extractPosition(item):
  260.         dom = xml.dom.minidom.Document()
  261.         pos = dom.createElement("position")
  262.         pos.setAttribute("time_from",str(item.time_from))
  263.         pos.setAttribute("time_to",str(item.time_to))
  264.         pos.setAttribute("track",item.track)
  265.         try:
  266.                 pos.setAttribute("direction",item.direction)
  267.         except AttributeError:
  268.                 pass
  269.                 
  270.                 
  271.         dom.unlink()
  272.         return pos
  273.                 
  274. def extractParams(dict):
  275.         dom = xml.dom.minidom.Document()
  276.         params = dom.createElement("params")
  277.         for item in dict.items():
  278.                 param = dom.createElement("param")
  279.                 param.setAttribute("name",item[0])
  280.                 param.appendChild(dom.createTextNode(item[1]))
  281.                 params.appendChild(param)
  282.         return params
  283.         dom.unlink()
  284.  
  285. def extractFilters(list,filters):
  286.         dom = xml.dom.minidom.Document()
  287.         for item in list:
  288.                 filter = dom.createElement("filter")
  289.                 filter.setAttribute("name",item.name)
  290.                 if item.active:
  291.                         filter.setAttribute("active","true")
  292.                 else: filter.setAttribute("active","false")
  293.  
  294.                 params = extractParams(item.params)
  295.                 filter.appendChild(params)
  296.                 filters.appendChild(filter)
  297.  
  298. def extractTransitions(data,node):
  299.         dom = xml.dom.minidom.Document()
  300.         for trans in data.transitions:
  301.                 tr = dom.createElement("transition_object")
  302.                 tr.setAttribute("id",trans.id)
  303.                 pos = extractPosition(trans)
  304.                 tr.appendChild(pos)
  305.                 tr2 = dom.createElement("transition")
  306.                 tr2.setAttribute("name",trans.name)
  307.                 params = extractParams(trans.params)
  308.                 tr2.appendChild(params)
  309.                 tr.appendChild(tr2)
  310.                 node.appendChild(tr)
  311.                 
  312.         dom.unlink()
  313.         
  314. def extractGroups(data,node):
  315.         dom = xml.dom.minidom.Document()
  316.         for group in data.groups:
  317.                 gr = dom.createElement("group")
  318.                 gr.setAttribute("id",group.id)
  319.                 for object in group.objects:
  320.                         item = dom.createElement("item")
  321.                         item.setAttribute("ref",object.id)
  322.                         gr.appendChild(item)
  323.                 node.appendChild(gr)
  324.         dom.unlink()
  325.  
  326.  
  327. #test function
  328. def simple_test(file_name):
  329.         dom1 = xml.dom.minidom.parse(file_name)
  330.         data = dom_to_data(dom1)
  331.         dom1.unlink()
  332.  
  333.         dom2 = data_to_dom(data,"http://openvip.sourceforge.net/timeline-format","1.0")
  334.         f=open('workfile.xml', 'w')
  335.         f.write(dom2.toxml())
  336.         f.close()
  337.         dom2.unlink()
  338.  
  339. #simple_test("test.xml")
  340.