#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
"""Advene http server.
This module defines a number of classes that describe the structure of
the Advene webserver. The L{AdveneWebServer} class is the main server
class.
URL syntax
==========
The URL syntax is described in each decription class.
The server can run standalone or embedded in another application
(typically the C{advene} GUI). In all cases, Webserver depends on
AdveneController.
"""
import advene.core.config as config
import advene.core.version
import sys
import os
import re
import urllib
import cgi
import socket
import imghdr
from gettext import gettext as _
import cherrypy
if int(cherrypy.__version__.split('.')[0]) < 3:
raise _("The webserver requires version 3.0 of CherryPy at least.")
from advene.model.fragment import MillisecondFragment
from advene.model.annotation import Annotation, Relation
from advene.model.view import View
from advene.model.resources import Resources
from advene.model.exception import AdveneException
import simpletal.simpleTAL
import simpletal.simpleTALES as simpleTALES
import advene.util.helper as helper
DEBUG=True
class Common:
"""Common functionalities for all cherrypy nodes.
"""
def __init__(self, controller=None):
self.controller=controller
def _cpOnError(self):
"""Error message handling.
"""
err = sys.exc_info()
if DEBUG:
print "Error handling"
import traceback, StringIO
bodyFile = StringIO.StringIO()
traceback.print_exc(file = bodyFile)
cherrypy.response.status=500
cherrypy.response.headers['Content-type']='text/html'
cherrypy.response.body = ["""Advene - Error Sorry, an error occured. %s """ % bodyFile.getvalue() ]
bodyFile.close()
else:
# Do something else here.
cherrypy.response.body = ['Error: ' + str(err[0])]
def location_bar (self):
"""Returns a string representing the active location bar.
This method will use the current URL path, and return an HTML string
where the different components of the path are linked to their URL.
@return: a HTML string
@rtype: string
"""
s = urllib.splittag(
urllib.splitquery(cherrypy.request.path_info)[0]
)[0]
path = s.split('/')[1:]
return """/ """ + "/".join(
["""%s """
% (uri, name)
for (name, uri) in zip(path,
["/"+"/".join(path[:i+1])
for i in range(len(path))])]
)
def no_cache (self):
"""Write the cache-control headers in the response.
This method sends cache-control headers to ensure that the
browser does not cache the response, as it may vary from one
call to another.
@return: nothing
"""
cherrypy.response.headers['Pragma']='no-cache'
cherrypy.response.headers['Cache-Control']='max-age=0'
def start_html (self, title="", headers=None, head_section=None, body_attributes="",
mode=None, mimetype=None, duplicate_title=False, cache=False):
"""Starts writing a HTML response (header + common body start).
@param title: Title of the HTML document (default : "")
@type title: string
@param headers: additional headers to add
@type headers: a list of tuples (keyword, value)
@param head_section: additional HTML code to add in the section
@type head_section: string
@param body_attributes: attributes added to the body tag
@type body_attributes: string
@param mode: presentation mode (navigation, raw). Default: navigation
@type mode: string
@param duplicate_title: duplicate title as HTML header (h1)
@type duplicate_title: boolean
@param cache: make the document cacheable. Default: False
@type cache: boolean
@return: nothing
"""
if mode is None:
mode = config.data.webserver['displaymode']
cherrypy.response.status=200
if mode == 'navigation' or mimetype is None or mimetype == 'text/html':
mimetype='text/html; charset=utf-8'
# Enforce utf-8 encoding on all text resources
if mimetype.startswith('text/') and 'charset' not in mimetype:
mimetype += '; charset=utf-8'
cherrypy.response.headers['Content-type']=mimetype
if headers is not None:
for h in headers:
cherrypy.request.headers[h[0]]=h[1]
if not cache:
self.no_cache ()
res=[]
if mode == "navigation":
res.append("""%s
Server administration |
Media control |
Raw view
Location: %(locationbar)s
%s \n" % title)
return "".join(res)
def send_no_content(self):
"""Sends a No Content (204) response.
Mainly used in /media handling.
"""
cherrypy.response.status=204
self.no_cache ()
return ""
def send_redirect (self, location):
"""Sends a redirect response.
As this method generates headers, it must be called before other
headers or content.
If the value of C{location} is C{no_content}, then a 204
response (No Content) will be sent. This can be useful in
cases where we want to keep on the same origin document.
@param location: the URL to redirect to.
@type location: string (URL)
"""
#cherrypy.response.string=301
#self.no_cache ()
#cherrypy.response.headers["Location"]=location
#cherrypy.response.headers['Content-type']='text/html; charset=utf-8'
#
#return _("""
#Redirect to %(location)s
#
#You should be redirected to %(location)s
#
#""") % {'location':location}
if location == 'no_content':
return self.send_no_content()
raise cherrypy.HTTPRedirect(location)
def send_error (self, status=404, message=None):
"""Sends an error response.
@param message: the error message
@type message: string
"""
if message is None:
message=_("Unspecified Error")
raise cherrypy.HTTPError(status, _("""
Error
An error occurred:
%s
""") % message)
def image_type (self, o):
"""Return the image type (mime) of the object.
This method examines the content of the given object, and
returns either a mime-type if it is an image, I{None} if it is
not.
@param o: an object
@type o: any
@return: the content-type if o is an image, else None
@rtype: string
"""
res=imghdr.what (None, str(o))
if res is not None:
return "image/%s" % res
else:
return None
def display_media_status (self):
"""Display current media status.
This method is called from another embedding method (which
will generate the appropriate headers). It displays the current
status of the media player.
"""
res=[]
if self.controller.player == None:
res.append(_("""No available mediaplayer """))
else:
l = self.controller.player.playlist_get_list ()
self.controller.update_status ()
res.append(_("""
Current STBV: %(currentstbv)s
Player status
Current position %(position)s
Duration %(duration)s
Player status %(status)s
""") % {
'currentstbv': str(self.controller.current_stbv),
'position': helper.format_time(self.controller.player.current_position_value),
'duration': helper.format_time(self.controller.player.stream_duration),
'status': repr(self.controller.player.status)
})
if len(l) == 0:
res.append (_("""No playlist """))
else:
res.append (_("""Current playlist
""") % ("\n".join ([ str(i) for i in l ])))
res.append (_("""
Stop | Pause %s has been added to the playlist
""") % name)
res.append(self.display_media_status ())
return "".join(res)
load.exposed=True
def snapshot(self, *args, **params):
"""Return the snapshot for the given position.
"""
# snapshot syntax: /media/snapshot/package_alias/NNNN
res=[]
if not args:
res.append(self.start_html (_("Access to packages snapshots"), duplicate_title=True, mode='navigation'))
res.append ("")
for alias in self.controller.packages.keys ():
res.append ("""%s ")
return "".join(res)
alias = args[0]
try:
i = self.controller.packages[alias].imagecache
except KeyError:
return self.send_error(400, _("Unknown package alias"))
try:
position=long(args[1])
except IndexError:
# No position was given. Display all available snapshots
res.append(self.start_html (_("Available snapshots for %s") % alias, duplicate_title=True, mode='navigation'))
if (params.has_key('mode') and params['mode'] == 'inline'):
template=""" Display with no inline images
""" % alias)
else:
template="""%(position)d (%(status)s)Display with inline images
""") % alias)
res.append ("")
k = i.keys ()
k.sort ()
for position in k:
if i.is_initialized (position):
m = _("Done")
else:
m = _("Pending")
res.append (template % { 'alias': alias,
'position': position,
'status': m })
res.append (" ")
return "".join(res)
if not i.is_initialized (position):
self.no_cache ()
if 'async-snapshot' in self.controller.player.player_capabilities:
self.controller.queue_action(self.controller.update_snapshot, position)
snapshot=i[position]
cherrypy.response.headers['Content-type']=snapshot.contenttype
res.append (str(snapshot))
return res
snapshot.exposed=True
def overlay(self, *args, **params):
"""Return the overlayed snapshot for the given annotation.
Snapshot syntax: /media/overlay/package_alias/id
The expression can be followed by a TALES expression, which is
then used to specify the element to display.
For instance,
/media/overlay/advene/a25/fragment/begin/formatted
or
/media/overlay/advene/a25/content/parsed/name
"""
res=[]
if not args:
res.append(self.start_html (_("Access to packages snapshots"), duplicate_title=True, mode='navigation'))
res.append ("")
for alias in self.controller.packages.keys ():
res.append ("""%s ")
return "".join(res)
alias = args[0]
try:
p=self.controller.packages[alias]
except KeyError:
return self.send_error(400, _("Unknown package alias"))
try:
a=p.get_element_by_id(args[1])
except IndexError:
return self.send_error(400, _("Unknown annotation id: %s") % args[1])
position=a.fragment.begin
if not p.imagecache.is_initialized(position):
self.no_cache()
snapshot=p.imagecache[position]
if args[2:]:
# There is a format specifier. It should be a TALES
# expression that will be applied to the annotation (no
# need to specify here).
path=[ 'here' ]
path.extend(args[2:])
path='/'.join(path)
ctx=self.controller.build_context(here=a)
svg_data=unicode( ctx.evaluateValue(path) )
elif 'svg' in a.content.mimetype:
# Overlay svg
svg_data=a.content.data
else:
# Overlay annotation title
svg_data=self.controller.get_title(a)
if self.controller.gui:
img=self.controller.gui.overlay(snapshot, svg_data, other_thread=True)
else:
img=snapshot
cherrypy.response.headers['Content-type']='image/png'
res.append (str(img))
return res
overlay.exposed=True
def play(self, begin=None, end=None, **params):
"""Play the movie.
Optional parameters:
- stbv: the id of the dynamic view that should be activated
- filename: the filename of the movie
- position: the position in ms
"""
c=self.controller
if params.has_key('stbv'):
self.activate_stbvid(params['stbv'])
if params.has_key ('filename'):
c.queue_action(c.set_media, params['filename'])
if not c.player.playlist_get_list():
return self.send_no_content()
if begin is None:
try:
begin=params['position']
except KeyError:
begin=0
pos=c.create_position (value=long(begin),
key=c.player.MediaTime,
origin=c.player.AbsolutePosition)
c.queue_action( c.update_status, "start", pos )
return self.send_no_content()
play.exposed=True
def pause(self, **params):
"""Pause the movie.
Optional parameters:
- stbv: the id of the dynamic view that should be activated
"""
if params.has_key('stbv'):
self.activate_stbvid(params['stbv'])
self.controller.queue_action(self.controller.update_status, 'pause')
return self.send_no_content()
pause.exposed=True
def stop(self, **params):
"""Stop the movie.
Optional parameters:
- stbv: the id of the dynamic view that should be activated
"""
if params.has_key('stbv'):
self.activate_stbvid(params['stbv'])
self.controller.queue_action(self.controller.update_status, 'stop')
return self.send_no_content()
stop.exposed=True
def resume(self, **params):
"""Resume the movie.
Optional parameters:
- stbv: the id of the dynamic view that should be activated
"""
if params.has_key('stbv'):
self.activate_stbvid(params['stbv'])
self.controller.queue_action(self.controller.update_status, 'resume')
return self.send_no_content()
resume.exposed=True
def current(self):
"""Return the currently playing movie file.
"""
cherrypy.response.headers['Content-type']='text/plain'
l=self.controller.player.playlist_get_list()
if l:
return l[0]
else:
return 'N/C'
current.exposed=True
def stbv(self, *args, **query):
"""Activate the given stbv.
"""
if not args and not query.has_key('id'):
cherrypy.response.headers['Content-Type']='text/plain'
return self.controller.current_stbv.id or 'None'
else:
if args:
stbvid=args[0]
else:
stbvid=query['id']
if stbvid == 'None':
stbvid=None
try:
self.activate_stbvid(stbvid)
except Exception, e:
return self.send_error(400, _("Cannot activate stbvid %(stbvid)s: %(error)s") % { 'stbvid': stbvid,
'error': unicode(e) })
return self.send_redirect("/application/")
stbv.exposed=True
class Application(Common):
"""Handles X{/application} access requests.
Tree organization
=================
The C{/application} folder gives the ability to acces the application (GUI).
The elements available in this folder are :
- C{/application/stbv}
- C{/application/adhoc}
- C{/application/config}
Accessing the folder itself will display the application status.
The X{/application/stbv} element
--------------------------------
C{/application/stbv} activates the given STBV. It takes the STBV id as
next element in the path, or as C{id=...} parameter. Note that it only
activates the STBV. To activate the STBV and start the player, use the
C{/application/play?stbv=...} URI.
The X{/application/adhoc} element
---------------------------------
C{/application/adhoc} opens the given ad-hoc view. It takes
the view name as next element in the path. Accessible views
are: C{tree}, C{timeline}, C{transcription}, C{transcribe},
C{edit}, C{bookmarks}, C{browser}.
The transcription view can take an optional C{type}
parameter, either as next element in the URI or as a
C{type=...} parameter. To open the transcription view on the
annotation-type simple_text, you can simply use:
C{/application/adhoc/transcription/simple_text}
The transcribe view takes a mandatory C{url} parameter.
The edit view takes a mandatory C{id} parameter, which is
the id of the element to be edited.
The X{/application/config} element
----------------------------------
C{/application/config} gives access to configuration information
as stored in the C{config.data.web} dictionary.
Using the C{GET} method returns the value of the
information. Using the C{PUT} method updates the configuration
information.
"""
def current_adhoc(self):
"""Display currently opened adhoc views.
"""
res=[]
c=self.controller
if not c.gui:
res.append(_("""No GUI is available."""))
else:
res.append(_("""
Opened adhoc views: %s
""") % ", ".join([ v.view_name for v in c.gui.adhoc_views]))
res.append(_("""Available adhoc views:
"""))
l=c.gui.registered_adhoc_views.keys()
l.sort()
for name in l:
view=c.gui.registered_adhoc_views[name]
try:
description=": " + view.tooltip
except AttributeError:
description=""
res.append("""%(name)s %(description)s ")
return "".join(res)
def current_stbv(self):
"""Display currently active STBV.
"""
res=[]
c=self.controller
res.append(_("""Current stbv: %s
""") % c.get_title(c.current_stbv))
res.append(_("""You can activate the following STBV:
""")
% "\n".join( [ """%s (%s )The GUI view %s does not exist.
""") % view)
adhoc.exposed=True
def config(self, *args, **query):
"""Set config variable value.
"""
if not args:
return self.send_error(500, _("Invalid request"))
name=args[0]
try:
v=config.data.web[name]
except KeyError:
return self.send_error(500, _("Invalid configuration variable name"))
if cherrypy.request.method == 'GET':
cherrypy.response.headers['Content-Type']='text/plain'
return str(v)
elif cherrypy.request.method == 'PUT':
data=cherrypy.request.rfile.read()
# Convert the type.
if isinstance(v, int) or isinstance(v, long):
try:
data=long(data)
except ValueError:
return self.send_error(500, _("Invalid value"))
config.data.web[name]=data
return self.send_no_content()
else:
return self.send_error(500, _("Unsupported method %s") % cherrypy.request.method)
config.exposed=True
class Access(Common):
"""Displays the access control menu.
Access Control
==============
Access control is available in the AdveneServer through the
path X{/admin/access}. By default, only the localhost (IP
address 127.0.0.1) is allowed to access the server. The user
can add or delete hosts from the access list, but the
localhost can never be removed from the access list.
The addition or removal of a computer is done through URLs:
X{/admin/access/add/hostname} and X{/admin/access/delete/hostname}
If no options are given, the current access control list is
displayed.
"""
def display_access_list(self):
"""Display the current access list.
"""
return _("""
Authorized hosts
""") % "\n".join(["""%(name)s %(ip)s Remove Error: %s is an invalid hostname. """) % hostname)
if ip is not None:
self.controller.server.authorized_hosts[ip] = hostname
res.append (_("""Added %s to authorized hosts list.
""") % hostname)
res.append(self.display_access_list())
return "".join(res)
add.exposed=True
def delete(self, hostname):
res=[self.start_html(_('Access control - delete a hostname'), duplicate_title=True, mode='navigation')]
ip=None
try:
ip = socket.gethostbyname (hostname)
except socket.error:
res.append (_("""Error: %s is an invalid hostname. """) % hostname)
if ip == '127.0.0.1':
res.append(_("""Cannot remove the localhost access. """))
elif ip is not None:
# Remove the hostname
if ip in self.controller.server.authorized_hosts:
del self.controller.server.authorized_hosts[ip]
res.append (_("""Removed %s from authorized hosts list.
""") % hostname)
else:
res.append (_("""%s is not in authorized hosts list.
""") % hostname)
res.append(self.display_access_list())
return "".join(res)
delete.exposed=True
class Admin(Common):
"""Handles the X{/admin} requests.
The C{/admin} folder contains the following elements for the
administration of the server:
- C{/admin/list} : display the list of currently loaded packages
- C{/admin/load} : load a new package
- C{/admin/save/alias} : save a package
- C{/admin/delete/alias} : remove a loaded package
- C{/admin/access} : display access control list
- C{/admin/status} : display current status
- C{/admin/display} : display or set the default webserver display mode
- C{/admin/methods} : list the available global methods
- C{/admin/halt} : halt the webserver
Accessing the C{/admin} folder itself displays the summary
(equivalent to the root document).
Loading, saving or deleting packages is done by specifying the
C{alias} parameter. In the case of the C{/admin/load} action,
the C{uri} parameter must provide the appropriate URI.
Setting the X{display mode}
===========================
Accessing the C{/admin/display} element updates the server
display mode. The data should be available as a parameter
named C{mode}, which is either C{default} or C{raw}, or as
last element in the URI, for instance
C{/admin/display/navigation}
@param l: the access path as a list of elements,
with the initial one (C{access}) omitted
@type l: list
@param query: the options given in the URL
@type query: dict
"""
def index(self):
"""Display the main administration page.
This method displays the administration page of the server, which
should link to all functionalities.
"""
res=[ self.start_html (_("Server Administration"), duplicate_title=True, mode='navigation') ]
if self.controller.server.displaymode == 'raw':
switch='navigation'
else:
switch='raw'
mode_sw="""%(mode)s (switch to %(switch)s )""" % {
'mode': self.controller.server.displaymode, 'switch': switch }
res.append(_("""
Update the access list
List available TALES methods
List available actions
Reset the server
Media control
Display GUI status
List available files
List loaded packages (%(packagelist)s)
Display mode : %(displaymode)s
Load a package :
""") % { 'packagelist': " | ".join( ['%s ' % (alias, alias)
for alias in self.controller.packages.keys() ] ),
'displaymode': mode_sw })
return "".join(res)
index.exposed=True
def list(self):
"""Display available Advene files.
This method displays the data files in the data directory.
Maybe it should be removed when the server runs embedded.
"""
res=[ self.start_html (_("Available files"), duplicate_title=True, mode='navigation') ]
res.append ("")
l=[ os.path.join(config.data.path['data'], n)
for n in os.listdir(config.data.path['data'])
if n.lower().endswith('.xml') or n.lower().endswith('.azp') ]
l.sort(lambda a, b: cmp(a.lower(), b.lower()))
for uri in l:
name, ext = os.path.splitext(uri)
alias = re.sub('[^a-zA-Z0-9_]', '_', os.path.basename(name))
res.append ("""
%(uri)s
""")
return "".join(res)
list.exposed=True
def load(self, *args, **query):
"""Load the specified URI with the given alias.
"""
try:
alias = query['alias']
except KeyError:
return self.send_error (501,
_("""You should specify an alias"""))
try:
uri = query['uri']
except KeyError:
return self.send_error (501,
_("""You should specify an uri"""))
try:
# FIXME: potential problem: this method executes in the webserver thread, which may
# cause problems with the GUI
self.controller.load_package (uri=uri, alias=alias)
return "".join( (
self.start_html (_("Package %s loaded") % alias, duplicate_title=True, mode='navigation'),
_("""Go to the %(alias)s package, or to the package list .""") % { 'alias': alias }
))
except Exception, e:
return self.send_error(501, _("""
Cannot load package %(alias)s : %(error)s
""" % {
'alias': alias,
'error': str(e) }))
load.exposed=True
def delete(self, alias):
"""Unload a package.
"""
try:
self.controller.unregister_package (alias)
return "".join((
self.start_html (_("Package %s deleted") % alias, duplicate_title=True, mode='navigation'),
_("""Go to the package list .""")
))
except Exception, e:
return self.send_error(501, _("""
Cannot delete package %(alias)s : %(error)s
""" % {
'alias': alias,
'error': str(e) }
))
delete.exposed = True
def save(self, alias=None):
"""Save a package.
"""
try:
if alias is not None:
# Save a specific package
self.controller.save_package(alias=alias)
else:
self.controller.save_package()
alias='default'
return "".join((
self.start_html (_("Package %s saved") % alias, duplicate_title=True, mode='navigation'),
_("""Go to the %(alias)s package, or to the package list .""") % { 'alias': alias }
))
except Exception, e:
return self.send_error(501, _("""
Cannot save package %(alias)s : %(error)s
""" % {
'alias': alias,
'error': str(e) }
))
save.exposed=True
def reset(self):
"""Reset packages list.
"""
self.controller.reset()
return self.start_html (_('Server reset'), duplicate_title=True, mode='navigation')
reset.exposed=True
def methods(self):
"""Display available TALES methods.
"""
res=[ self.start_html (_('Available TALES methods'), duplicate_title=True, mode='navigation') ]
res.append('')
c=self.controller.build_context(here=None)
k=c.methods.keys()
k.sort()
for name in k:
descr=c.methods[name].__doc__
if descr:
descr=descr.split('\n')[0]
res.append("%s : %s ")
return "".join(res)
methods.exposed=True
def display(self, mode=None):
"""Set display mode.
"""
if mode:
# Set default display mode
if mode in ('raw', 'navigation'):
self.controller.server.displaymode=mode
ref=cherrypy.request.headers.get('Referer', "/")
return self.send_redirect(ref)
else:
# Display status
cherrypy.response.status=200
cherrypy.response.headers['Content-type']='text/plain'
self.no_cache ()
return self.controller.server.displaymode
display.exposed=True
class Packages(Common):
"""Node for packages access.
"""
def index(self):
"""Display currently available (loaded) packages.
This method displays the list of currently loaded
packages. The generated list provides links for accessing,
reloading, saving or removing the package.
"""
res=[ self.start_html (_("Loaded package(s)"), mode='navigation') ]
res.append (_("""
Loaded package(s)
Alias
Action
URI
Annotations
"""))
for alias in self.controller.packages.keys():
p = self.controller.packages[alias]
res.append (_("""
%(alias)s Reload |Drop |Save %(uri)s
%(size)d
""") % { 'alias':alias, 'uri':p.uri, 'size':len(p.annotations) })
res.append ("""
""")
return "".join(res)
index.exposed=True
def display_package_element (self, p, tales, query=None):
"""Display a view for a TALES expression.
This method displays the view for the element defined by the
expression C{tales} wrt to package C{p}, with facultative
parameters in C{query}. It handles the X{/packages} folder.
The query can hold an optional parameter, named C{mode}, which
indicates a specific display mode for the resulting
object. Valid modes are:
- C{image} : the object is an image, and we generate the
correct headers.
- C{raw} : do not display the navigation interface, but only the
object's view
- C{content} : return the content data of an object, with
its specific mime-type
- C{default} : default mode, with navigation interface
The C{display mode} has a default value at the server level,
wich can be set through the C{/admin} folder.
An autodetect feature will force the display mode to C{image}
if the object is an image (depending on the return value of
L{image_type}).
All other other parameters given on the URL path are kepts in
the C{query} dictionary, which is available in TALES
expressions through the C{request/} root element.
@param p: the package in which the expression should be evaluated
@type p: advene.model.Package
@param tales: a TALES expression
@type tales: string
@param query: options used in TAL/TALES processing
@type query: dict
"""
res=[]
alias = self.controller.aliases[p]
if query is None:
query={}
if tales == "":
expr = "here"
elif tales.startswith ('options'):
expr = tales
else:
expr = "here/%s" % tales
context = self.controller.build_context (here=p, alias=alias)
context.pushLocals()
context.setLocal('request', query)
# FIXME: the following line is a hack for having qname-keys work
# It is a hack because obviously, p is not a "view"
context.setLocal (u'view', p)
try:
objet = context.evaluateValue (expr)
except AdveneException, e:
self.start_html (_("Error"), duplicate_title=True, mode='navigation')
res.append (_("""The TALES expression %s is not valid.""") % tales)
res.append (unicode(e.args[0]).encode('utf-8'))
return
displaymode = self.controller.server.displaymode
# Hack to automatically switch to an image view for image objects.
# FIXME: we should find a clean solution (for instance a new object
# with a content-type method : if it is HTML, we return it normally ;
# if it is some other thing, we return it with the correct content-type
# header).
if query.has_key('mode'):
displaymode = query['mode']
del (query['mode'])
if isinstance(objet, str) and self.image_type (objet) is not None:
displaymode = 'image'
if displaymode == 'image':
# Return an image, so build the correct headers
try:
mimetype=expr.contenttype
except AttributeError:
mimetype=self.image_type(str(objet))
if 'imagecache' in expr and 'async-snapshot' in self.controller.player.player_capabilities:
# Probably an image from the imagecache. Check if it
# is initialized, else ask if possible for update.
t=getattr(objet, 'timestamp', None)
if t is not None and t < 0:
# Non-initialized snapshot. Ask for update.
ts=re.findall('imagecache/(\d+)', expr)
if ts:
self.controller.queue_action(self.controller.update_snapshot, long(ts[0]))
cherrypy.response.status=200
cherrypy.response.headers['Content-type']=mimetype
self.no_cache ()
res.append (str(objet))
return "".join(res)
elif displaymode == 'content':
if hasattr(objet, 'mimetype'):
cherrypy.response.status=200
cherrypy.response.headers['Content-type']=objet.mimetype
self.no_cache ()
res.append (objet.data)
return "".join(res)
elif hasattr(objet, 'contenttype'):
cherrypy.response.status=200
cherrypy.response.headers['Content-type']=objet.contenttype
self.no_cache ()
res.append (objet)
return "".join(res)
else:
return self.send_error (404, _("Content mode not available on non-content data"))
# Last case: default or raw
if displaymode != "raw":
displaymode = "navigation"
# Display content
if hasattr (objet, 'view') and callable (objet.view):
context = self.controller.build_context(here=objet, alias=alias)
context.pushLocals()
context.setLocal('request', query)
# FIXME: should be default view
context.setLocal(u'view', objet)
try:
v=objet.view (context=context)
res.append( self.start_html(mimetype=v.contenttype) )
if v.contenttype.startswith('text'):
res.append (unicode(v).encode('utf-8'))
else:
res.append(v)
except simpletal.simpleTAL.TemplateParseException, e:
res.append( self.start_html(_("Error")) )
res.append(_("Error "))
res.append(_("""There was an error in the template code.
Tag name: %(tagname)s
Error message: %(message)s
""") % {
'tagname': cgi.escape(e.location),
'message': e.errorDescription} )
return "".join(res)
except simpleTALES.ContextContentException, e:
res.append( self.start_html(_("Error")) )
res.append(_("Error "))
res.append(_("""An invalid character is in the Context:
Error message: %(error)s
%(message)s """)
% {'error': e.errorDescription,
'message': unicode(e.args[0]).encode('utf-8')})
return "".join(res)
except AdveneException, e:
res.append( self.start_html(_("Error")) )
res.append(_("Error "))
res.append(_("""There was an error in the TALES expression.
%s """) % cgi.escape(unicode(e.args[0]).encode('utf-8')))
return "".join(res)
else:
mimetype=None
try:
mimetype = objet.mimetype
except AttributeError:
try:
mimetype = objet.contenttype
except AttributeError:
pass
try:
res.append( self.start_html(mimetype=mimetype) )
if mimetype and mimetype.startswith('text'):
res.append (unicode(objet).encode('utf-8'))
else:
res.append(str(objet))
except AdveneException, e:
res.append(_("Error "))
res.append(_("""There was an error.
%s """) % cgi.escape(unicode(e.args[0]).encode('utf-8')))
except simpletal.simpleTAL.TemplateParseException, e:
res.append(_("Error "))
res.append(_("""There was an error in the template code.
Tag name: %(tagname)s
Error message: %(message)s
""") % {
'tagname': cgi.escape(e.location),
'message': e.errorDescription})
# Generating navigation footer
if displaymode == 'navigation' and 'html' in cherrypy.response.headers['Content-type']:
uri=cherrypy.request.path_info
levelup = uri[:uri.rindex("/")]
auto_components = [ c
for c in helper.get_valid_members (objet)
if not c.startswith('----') ]
auto_components.sort()
try:
auto_views = objet.validViews
auto_views.sort()
except AttributeError:
auto_views = []
res.append (_("""
Location: %(location)s
""")
res.append (_("""Evaluating expression "%(expression)s " on package %(uri)s returns %(value)s
""") % {
'expression': tales ,
'uri': p.uri,
'value': cgi.escape(str(type(objet)))})
return "".join(res)
def default(self, *args, **query):
"""Access a specific package.
URL handling
============
The URL is first split in components, and some parameters may
modify the interpretation of the path.
The C{path} parameter is used to interactively modifying the
path (through a form).
Else, the C{path} value will be appended to the current path
of the URL, and the browser is redirected to this new location.
The C{view} parameter is a shortcut for rapidly accessing an
element view. Its value is in fact the URL displaying the
correct view, and the browser is redirected.
"""
if not args:
return self.index()
pkgid = args[0]
try:
p = self.controller.packages[pkgid]
except KeyError:
return self.send_error (501, _("Package %s not loaded
")
% pkgid)
# Handle form parameters (from the navigation interface)
if query.has_key('view'):
if query['view'] != '':
# The 'view' parameter is in fact the new path
# that we should redirect to
return self.send_redirect (query['view'])
else:
# If the submit was done automatically on "path" modification,
# the view field will exist but be empty, so delete it
del(query['view'])
if query.has_key('path'):
# Append the given path to the current URL
p="/".join( (cherrypy.url(), query['path']) )
if query['path'].find ('..') != -1:
p = os.path.normpath (p)
del(query['path'])
if len(query) == 0:
location = p
else:
location = "%s?%s" % (p,
"&".join (["%s=%s" % (k,urllib.quote(query[k]))
for k in query.keys()]))
return self.send_redirect (location)
tales = "/".join (args[1:])
if cherrypy.request.method == 'PUT':
return self.handle_put_request(*args, **query)
elif cherrypy.request.method == 'POST':
return self.handle_post_request(*args, **query)
elif cherrypy.request.method != 'GET':
return self.send_error(400, 'Unknown method: %s' % cherrypy.request.method)
try:
return self.display_package_element (p , tales, query)
except simpletal.simpleTAL.TemplateParseException, e:
res=[ self.start_html(_("Error")) ]
res.append(_("Error "))
res.append(_("""There was an error in the template code.
Tag name: %(tagname)s
Error message: %(message)s
""") % {
'tagname': cgi.escape(e.location),
'message': e.errorDescription })
except AdveneException, e:
res=[ self.start_html(_("Error")) ]
res.append(_("Error "))
res.append(_("""There was an error in the expression.
%s """) % cgi.escape(unicode(e.args[0]).encode('utf-8')))
except:
# FIXME: should use standard Cherrypy error handling.
t, v, tr = sys.exc_info()
import code
res=[ self.start_html(_("Error")) ]
res.append(_("Error "))
res.append(_("""Cannot resolve TALES expression %(expr)s on package %(package)s
%(type)s
%(value)s
%(traceback)s """) % {
'expr': tales,
'package': pkgid,
'type': unicode(tales),
'value': unicode(v),
'traceback': "\n".join(code.traceback.format_tb (tr)) })
return "".join(res)
default.exposed=True
def handle_put_request(self, *args, **query):
"""Handle PUT requests (update or create).
A PUT request done on an Advene element will try to update it
with the given content.
Data transmission
=================
Data can be transmitted either as a textual content (from a
Invalid request
."))
if not args:
return self.send_error(501, _("Error ") +
_("Cannot set the value : invalid path
"))
alias=args[0]
# Get the TALES expression of the element, and its attribute name
tales = "/".join (args[1:-1])
if len(alias) > 1:
attribute = args[-1]
else:
attribute = ''
if tales == "":
expr = "here"
else:
expr = "here/%s" % tales
package=self.controller.packages[alias]
context = self.controller.build_context(here=package, alias=alias)
context.pushLocals()
context.setLocal('request', query)
# Handle the various ways to transmit data
if 'datafile' in query:
# File upload.
data=query['datafile'].value
elif 'datapath' in query:
# A file path was specified. This will put the
# content of the path specified by 'datapath',
# from the server filesystem. This is a
# temporary and convenience hack to manage the
# uploading of resource files from the WYSIWYG
# editor.
# FIXME FIXME FIXME
# However it is a serious security issue, since:
# - in the non-embedded case, users may get
# the content of any file from the server.
# - in the embedded case (GUI embedding
# server), other users may access the files
# owned by the user running the application
# This should be addressed at some time...
data=open(query['datapath'], 'rb').read()
else:
data=query['data']
# Different actions : update, create, delete
if query['action'] == 'update':
try:
objet = context.evaluateValue (expr)
except Exception, e:
return self.send_error(501, _("Error ") + unicode(e.args[0]).encode('utf-8'))
if hasattr(objet, attribute):
objet.__setattr__(attribute, data)
if 'redirect' in query and query['redirect']:
return self.send_redirect(query['redirect'])
if expr.endswith('/content'):
# We have updated the content.data of an element
element = context.evaluateValue(expr[:-8])
if isinstance(element, View) and element.matchFilter['class'] in ('*', 'package'):
return self.send_redirect('/packages/advene/view/' + element.id)
else:
res=[ self.start_html(_("Value updated")) ]
res.append (_("""
Value updated
The value of %(path)s has been updated to
%(value)s
""") % { 'path': "/".join([tales, attribute]),
'value': cgi.escape(data) })
return "".join(res)
else:
# Fallback mode : maybe we were in a dict, and
# attribute is the id of the object in the dict
try:
objet[attribute]=data
if 'redirect' in query and query['redirect']:
return self.send_redirect(query['redirect'])
res=[ self.start_html(_("Value updated")) ]
res.append (_("""
Value updated
The value of %(path)s has been updated to
%(value)s
""") % { 'path': "%s[%s]" % (tales, attribute),
'value': cgi.escape(data) })
return "".join(res)
except TypeError:
# Not a dict...
return self.send_error(500, _("Malformed request: cannot update the value of %(attribute)s in %(tales)s.") % locals())
elif query['action'] == 'create':
# Creating an element. If it is a resource, its id is
# specified by its TALES path. For other types of elements
# (annotation, view, relation...), the TALES path must
# point to the package.
if query['type'] == 'resource':
if tales.startswith('resources'):
# Resource creation
path=tales.split('/')[1:]
parent=package.resources
if path:
# The resource is in a folder. Let's create the
# hierarchy first.
for i in range(1, len(path)+1):
subpath=path[:i]
try:
r = context.evaluateValue("here/resources/%s" % "/".join(subpath))
except AdveneException:
# The resource folder does not exist. Create it.
parent[subpath[-1]] = parent.DIRECTORY_TYPE
el=parent[subpath[-1]]
self.controller.notify('ResourceCreate',
resource=el)
r=el
if isinstance(r, Resources):
parent=r
else:
return self.send_error(501, (_("Error When creating resource %(path)s, the resource folder %(folder)s could not be created.
") % {
'path': '/'.join(path),
'folder': subpath[-1] }).encode('utf-8'))
parent[attribute]=data
el=parent[attribute]
self.controller.notify('ResourceCreate',
resource=el)
cherrypy.response.status=200
if 'redirect' in query and query['redirect']:
return self.send_redirect(query['redirect'])
return _("Resource successfuly created/updated")
# A TALES path was specified. We cannot handle this case.
if expr:
return self.send_error(500, _("Cannot create an element in something else than a package."))
objet=package
# Keyword parameters for each create* method
kw={}
def update_arg(formname, argname, default):
try:
kw[argname]=query[formname]
except KeyError:
kw[argname]=default
if query['type'] == 'view':
update_arg('id', 'ident', None)
if kw['ident'] is None:
kw['ident']=objet._idgenerator.get_id(View)
objet._idgenerator.add(kw['ident'])
elif objet._idgenerator.exists(kw['ident']):
return self.send_error(500, _("The identifier %s already exists.") % kw['ident'])
update_arg('mimetype', 'content_mimetype', 'text/html')
update_arg('class', 'clazz', 'package')
update_arg('author', 'author', config.data.userid)
kw['content_data']=data
kw['date']=self.controller.get_timestamp()
try:
v = objet.createView(**kw)
objet.views.append(v)
except Exception, e:
return self.send_error(500,
_("Error while creating view %(id)s
%(error)s ") % {
'id': kw['ident'],
'error': unicode(e).encode('utf-8') })
if 'redirect' in query and query['redirect']:
return self.send_redirect(query['redirect'])
return "".join( ( self.start_html(_("View created")),
_("""
View %(id)s created
The view %(id)s was successfully created.
""") % { 'id': v.id,
'url': "/packages/%s/views/%s" % (self.controller.aliases[objet],
v.id) }) )
elif query['type'] == 'relation':
# Takes as parameters:
# id = identifier (optional)
# relationtype = relation type identifier
# member1 = first member (annotation id)
# member2 = second member (annotation id)
# data = content data (optional)
for k in ('relationtype', 'member1', 'member2'):
if not query.has_key(k):
return self.send_error(500, _("Missing %s parameter") % k)
rt = context.evaluateValue("here/relationTypes/%s" % query['relationtype'])
if rt is None:
return self.send_error(500, _("Relation type %s does not exist") % query['relationtype'])
try:
id_ = query['id']
except KeyError:
id_ = objet._idgenerator.get_id(Relation)
m1 = context.evaluateValue('package/annotations/%s' % query['member1'])
if m1 is None:
return self.send_error(500, _("Annotation %s does not exist") % query['member1'])
m2 = context.evaluateValue('package/annotations/%s' % query['member2'])
if m2 is None:
return self.send_error(500, _("Annotation %s does not exist") % query['member2'])
if rt not in helper.matching_relationtypes(objet, m1.type, m2.type):
return self.send_error(500, _("Cannot create relation between %(member1)s and %(member2)s: invalid type
") % query)
try:
relation=objet.createRelation(ident=id_,
members=(m1, m2),
type=rt)
objet._idgenerator.add(id_)
relation.content.data=data
objet.relations.append(relation)
self.controller.notify("RelationCreate", relation=relation)
except Exception, e:
query['error']=unicode(e).encode('utf-8')
return self.send_error(500, _("Error while creating relation between %(member1)s and %(member2)s :
%(error)s ") % query)
if 'redirect' in query and query['redirect']:
return self.send_redirect(query['redirect'])
return "".join( ( self.start_html(_("Relation created")),
_("""Relation %s created """) % (relation.id)) )
elif query['type'] == 'annotation':
# Takes as parameters:
# id = identifier (optional)
# annotationtype = relation type identifier
# begin, end = begin and end time (in ms)
# data = content data (optional)
at = context.evaluateValue("here/annotationTypes/%s" % query['annotationtype'])
if at is None:
return self.send_error(500, _("Annotation type %s does not exist") % query['annotationtype'])
try:
id_ = query['id']
except KeyError:
id_ = objet._idgenerator.get_id(Annotation)
try:
begin=long(query['begin'])
end=long(query['end'])
fragment=MillisecondFragment(begin=begin, end=end)
a=objet.createAnnotation(ident=id_, type=at, fragment=fragment)
objet._idgenerator.add(id_)
a.content.data = data
objet.annotations.append(a)
self.controller.notify("AnnotationCreate", annotation=a)
except Exception, e:
t, v, tr = sys.exc_info()
import code
return self.send_error(500, _("""Error while creating annotation of type %(type)s :
%(errortype)s
%(value)s
%(traceback)s """) % {
'type': query['annotationtype'],
'errortype': unicode(t),
'value': unicode(v),
'traceback': "\n".join(code.traceback.format_tb (tr))
})
if 'redirect' in query and query['redirect']:
return self.send_redirect(query['redirect'])
return self.start_html(_("Annotation %s created") % a.id)
else:
return self.send_error(500, _("Error: Cannot create an object of type %s.") % (query['type']))
else:
return self.send_error(500, _("Error: Cannot perform the action %(action)s on %(object)s") % { 'action': query['action'], 'object': cgi.escape(unicode(objet)) })
class Action(Common):
"""Handles the X{/action} requests.
The C{/action} folder allows to invoke the actions defined in
the ECA framework (i.e. the same actions as the dynamic rules).
Accessing the C{/action} folder itself displays the summary of
available actions.
"""
def index(self):
catalog=self.controller.event_handler.catalog
res=[ self.start_html(_("Available actions"), duplicate_title=True, mode='navigation') ]
res.append("")
d=dict(catalog.get_described_actions(expert=True).iteritems())
k=d.keys()
k.sort()
for name in k:
a=catalog.get_action(name)
if a.parameters:
# There are parameters. Display a link to the form.
res.append(_("""%(name)s: %(value)s""")
% {'name': name,
'value': d[name]})
res.append(a.as_html("/action/%s" % name))
else:
# No parameter, we can directly link the action
res.append(""" %s : %s"""
% ("/action/%s" % name,
name,
d[name]))
res.append(" ")
return "".join(res)
index.exposed=True
def default(self, *args, **query):
action=args[0]
catalog=self.controller.event_handler.catalog
try:
ra=catalog.get_action(action)
except KeyError:
return "".join((
self.start_html (_('Error'), duplicate_title=True),
_("""Unknown action
Action: %s """) % action
))
# Check for missing parameters
missing=[ p for p in ra.parameters if not p in query ]
if missing:
res=[ self.start_html (_('Error'), duplicate_title=True) ]
res.append (_('Missing parameter(s) :'))
for p in missing:
res.append('%s: %s ' % (p, ra.parameters[p]))
return "".join(res)
self.controller.queue_registered_action(ra, query)
return self.send_no_content()
default.exposed=True
class Root(Common):
"""Common methods for all web resources.
URL syntax
==========
The virtual tree served by this server has the following entry points :
- C{/admin} : administrate the webserver
- C{/packages} : access to packages
- C{/media} : control the player
- C{/action} : list and invoke Advene actions
- C{/application} : control the application
"""
def __init__(self, controller=None):
self.controller=controller
self.admin=Admin(controller)
self.admin.access=Access(controller)
self.action=Action(controller)
self.application=Application(controller)
self.media=Media(controller)
self.packages=Packages(controller)
def data(self, *p):
"""Placeholder for data static dir resource.
data is handled by cherrypy.staticdir tool.
"""
return _("Advene web resources")
data.exposed=True
def index(self):
"""Display the server root document.
"""
res=[ self.start_html (_("Advene webserver"), duplicate_title=True, mode='navigation') ]
res.append(_("""Welcome on the Advene webserver run by %(userid)s on %(serveraddress)s.
""") %
{
'userid': config.data.userid,
'serveraddress': cherrypy.request.base,
})
if len(self.controller.packages) == 0:
res.append(_(""" No package is loaded. You can access the server administration page .
"""))
else:
# It must be 2, since we always have a 'advene' key. but
# there could be some strange case where the advene key is
# not present?
if len(self.controller.packages) <= 2:
alias='advene'
p=self.controller.packages['advene']
defaultview=p.getMetaData(config.data.namespace, 'default_utbv')
if defaultview:
mes=_("""the loaded package's default view """) % {'alias': alias, 'view': defaultview}
else:
mes=_("""the loaded package's data """) % alias
else:
mes=_("""the loaded packages' data """)
res.append(_("""
You can either access %s or the server administration page .
""") % mes)
res.append(_("""
Document generated by Advene v. %s.
""") % (advene.core.version.version))
return "".join(res)
index.exposed=True
class AdveneWebServer:
"""Embedded HTTP server for the Advene framework.
This is an embedded HTTP Server dedicated to serving Advene
packages content, and interacting with a media player.
@ivar controller: the controller
@type controller: advene.core.controller.Controller
@ivar urlbase: the base URL for this server
@type urlbase: string
@ivar displaymode: the default display-mode
@type displaymode: string
@ivar authorized_hosts: the list of authorized hosts
@type authorized_hosts: dict
"""
def __init__(self, controller=None, port=1234):
"""HTTP Server initialization.
When running embedded, the server should be provided a
C{controller} parameter, responsible for handling package
loading and player interaction.
@param controller: the controller
@type controller: advene.core.controller.Controller
@param port: the port number the server should bind to
@type port: int
"""
self.controller=controller
settings = {
'global': {
'server.socket_port' : port,
# Should do this for ipv6:
#'server.socket_host' : '::',
# but looks like we cannot listen to both ipv4 and ipv6
# despite http://stackoverflow.com/questions/1555319/cherrypy-server-unavailable-from-anything-but-localhost
# but http://stackoverflow.com/questions/4140550/firefox-cant-establish-connection-with-localhost-while-running-a-cherrypy-tutori
#'server.socket_queue_size': 5,
#'server.protocol_version': "HTTP/1.0",
'log.screen': False,
'log.access_file': config.data.advenefile('webserver.log', 'settings'),
'log.error_file': config.data.advenefile('webserver-error.log', 'settings'),
'server.reverse_dns': False,
'server.thread_pool': 10,
'engine.autoreload_on': False,
#'server.environment': "development",
'server.environment': "production",
},
# '/admin': {
# 'session_authenticate_filter.on' :True
# },
}
cherrypy.config.update(settings)
self.displaymode = config.data.webserver['displaymode']
# Not used for the moment.
self.authorized_hosts = {'127.0.0.1': 'localhost'}
self.urlbase = u"http://localhost:%d/" % port
app_config={
'/favicon.ico': {
'tools.staticfile.on': True,
'tools.staticfile.filename': config.data.advenefile( ( 'pixmaps', 'advene.ico' ) ),
},
'/data': {
'tools.staticdir.on': True,
'tools.staticdir.dir': config.data.path['web'],
},
}
cherrypy.tree.mount(Root(controller), config=app_config)
try:
# engine.start *must* be started from the main thread.
cherrypy.engine.start()
except Exception, e:
self.controller.log(_("Cannot start HTTP server: %s") % unicode(e))
def start(self):
"""Start the webserver.
"""
def protected_start():
try:
cherrypy.engine.start()
except Exception, e:
self.controller.log(_("Cannot start HTTP server: %s") % unicode(e))
self.controller.queue_action(protected_start)
return True
def stop(self):
"""Stop the webserver.
"""
cherrypy.engine.exit()
def is_running(self):
return cherrypy.engine.state == cherrypy.engine.states.STARTED
advene-1.0/lib/advene/player/ 0000755 0001752 0001752 00000000000 11672132267 016017 5 ustar oaubert oaubert advene-1.0/lib/advene/player/vlcctypes.py 0000644 0001752 0001752 00000027732 11672132267 020420 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2009 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
"""VLC access using the python ctypes-based module.
"""
import advene.core.config as config
import os
try:
import advene.player.vlc as vlc
except ImportError:
vlc=None
name="VLC-ctypes video player"
def register(controller=None):
if vlc is None:
return False
controller.register_player(Player)
return True
if vlc is not None:
# Shortcut used for get_stream_information
MediaTime=vlc.PositionKey.MediaTime
# We store Status information as int, so that it is hashable
PlayingStatus=vlc.PlayerStatus.PlayingStatus.value
PauseStatus=vlc.PlayerStatus.PauseStatus.value
InitStatus=vlc.PlayerStatus.InitStatus.value
EndStatus=vlc.PlayerStatus.EndStatus.value
UndefinedStatus=vlc.PlayerStatus.UndefinedStatus.value
class Player(object):
"""Wrapper class for a native vlc.MediaControl object.
It provides some helper methods, and forwards other requests to
the vlc.MediaControl object.
@ivar mc: the vlc.MediaControl player
@type mc: vlc.MediaControl
@ivar relative_position: a predefined position (0-relative)
@type relative_position: vlc.Position
Status attributes :
@ivar current_position_value: the current player position (in ms)
@type current_position_value: int
@ivar stream_duration: the current stream duration
@type stream_duration: long
@ivar status: the player's current status
@type status: vlc.Status
"""
player_id='vlc'
player_capabilities=[ 'seek', 'pause', 'caption', 'svg' ]
if vlc is not None:
# Class attributes
AbsolutePosition=vlc.PositionOrigin.AbsolutePosition
RelativePosition=vlc.PositionOrigin.RelativePosition
ModuloPosition=vlc.PositionOrigin.ModuloPosition
ByteCount=vlc.PositionKey.ByteCount
SampleCount=vlc.PositionKey.SampleCount
MediaTime=vlc.PositionKey.MediaTime
# Status
PlayingStatus=vlc.PlayerStatus.PlayingStatus.value
PauseStatus=vlc.PlayerStatus.PauseStatus.value
InitStatus=vlc.PlayerStatus.InitStatus.value
EndStatus=vlc.PlayerStatus.EndStatus.value
UndefinedStatus=vlc.PlayerStatus.UndefinedStatus.value
# Exceptions
PositionKeyNotSupported=vlc.MediaControlException
PositionOriginNotSupported=vlc.MediaControlException
InvalidPosition=vlc.MediaControlException
class PlaylistException(Exception):
pass
class InternalException(Exception):
pass
def __getattribute__ (self, name):
"""
Use the defined method if necessary. Else, forward the request
to the mc object
"""
#print "********************** Getattr", name
try:
return object.__getattribute__ (self, name)
except AttributeError, e:
return self.mc.__getattribute__ (name)
raise self.InternalException(e)
def fullscreen(self, connect=None):
self.mc.set_fullscreen(True)
return True
def playlist_add_item(self, name):
self.mc.set_mrl(name)
def playlist_clear(self):
self.mc.set_mrl('')
def playlist_get_list(self):
return [ self.mc.get_mrl() ]
def is_active (self):
"""Checks whether the player is active.
@return: True if the player process is active.
@rtype: boolean
"""
return True
def stop_player(self):
"""Stop the player."""
return
def get_player_args (self):
"""Build the VLC player argument list.
@return: the list of arguments
"""
args=[]
filters=[]
args.append( '--intf=dummy' )
if os.path.isdir(config.data.path['plugins']):
args.append( '--plugin-path=%s' % config.data.path['plugins'] )
if config.data.player['verbose'] is not None:
args.append ('--verbose')
args.append (config.data.player['verbose'])
if config.data.player['vout'] != 'default':
args.append( '--vout=%s' % config.data.player['vout'] )
if config.data.player['svg']:
args.append( '--text-renderer=svg' )
if config.data.player['bundled']:
args.append( '--no-plugins-cache' )
if filters != []:
# Some filters have been defined
args.append ('--vout-filter=%s' %":".join(filters))
#print "player args", args
return [ str(i) for i in args ]
def restart_player (self):
"""Restart (cleanly) the player."""
del self.mc
self.args=self.get_player_args()
print "Before MC instanciation"
self.mc = vlc.MediaControl( self.args )
print "After MC instanciation"
# 0 relative position
pos = vlc.MediaControlPosition ()
pos.origin = self.RelativePosition
pos.key = self.MediaTime
pos.value = 0
self.relative_position = pos
self.dvd_device = config.data.player['dvd-device']
# Attributes updated by self.position_update
self.status = UndefinedStatus
self.current_position_value = 0
self.stream_duration = 0
return True
def exit (self):
self.stop_player()
def get_default_media (self):
"""Return the default media path (used when starting the player).
This method should be overriden by the mediacontrol parent.
"""
return None
def __init__ (self):
"""Wrapper initialization.
"""
self.mc=None
self.mute_volume=None
self.restart_player()
def update_status (self, status=None, position=None):
"""Update the player status.
Defined status:
- C{start}
- C{pause}
- C{resume}
- C{stop}
- C{set}
If no status is given, it only updates the value of self.status
If C{position} is None, it will be considered as zero for the
"start" action, and as the current relative position for other
actions.
@param status: the new status
@type status: string
@param position: the position
@type position: vlc.Position
"""
print "update_status", status
if status == "start":
if position is None:
position=self.create_position(0, self.MediaTime, self.AbsolutePosition)
elif not isinstance(position, vlc.MediaControlPosition):
p=long(position)
position=self.create_position(p, self.MediaTime, self.AbsolutePosition)
self.check_player ()
self.mc.start(position)
# Workaround for the unstable position parameter handling by start
self.mc.set_media_position(position)
else:
if position is None:
position = self.relative_position
elif not isinstance(position, vlc.MediaControlPosition):
p=long(position)
position=self.create_position(p, self.MediaTime, self.AbsolutePosition)
if status == "pause":
self.check_player ()
if self.status == PlayingStatus:
self.mc.pause ()
elif self.status == PauseStatus:
self.mc.resume ()
elif status == "resume":
self.check_player()
if self.status == PauseStatus:
self.mc.resume ()
else:
self.mc.start (position)
elif status == "stop":
self.check_player()
if not self.status in (EndStatus, UndefinedStatus):
self.mc.stop ()
elif status == "set":
self.check_player()
if self.status in (EndStatus, UndefinedStatus):
self.mc.start (position)
else:
self.mc.set_media_position (position)
elif status == "" or status == None:
pass
else:
print "******* Error : unknown status %s in mediacontrol.py" % status
self.position_update ()
def position_update (self):
"""Updates the current status information."""
mc=getattr(self, 'mc', None)
if mc is not None:
try:
s = mc.get_stream_information(MediaTime)
except Exception, e:
print "Exception", str(e)
raise self.InternalException(str(e))
# Make sure we store the (python) value of the status
self.status = s.status.value
self.stream_duration = s.length
self.current_position_value = s.position
self.url=s.url
# FIXME: the returned values are wrong just after a player start
# (pressing Play button)
# Workaround for now:
# If the duration is larger than 24h, then set it to 0
if self.stream_duration > 86400000:
self.stream_duration = 0
self.current_position_value = 0
else:
self.status = UndefinedStatus
self.stream_duration = 0
self.current_position_value = 0
self.url=''
def dvd_uri(self, title=None, chapter=None):
if self.dvd_device is None:
return ""
else:
return "dvdsimple://%s@%s:%s" % (self.dvd_device,
str(title),
str(chapter))
def create_position (self, value=0, key=None, origin=None):
"""Create a Position.
Returns a Position object initialized to the right value, by
default using a MediaTime in AbsolutePosition.
@param value: the value
@type value: int
@param key: the Position key
@type key: vlc.Key
@param origin: the Position origin
@type origin: vlc.Origin
@return: a position
@rtype: vlc.Position
"""
if key is None:
key=self.MediaTime
if origin is None:
origin=self.AbsolutePosition
p = vlc.MediaControlPosition ()
p.origin = origin
p.key = key
p.value=long(value)
return p
def check_player(self):
return True
def snapshot(self, position):
# Do not update the snapshot if we are not playing
if self.status != PlayingStatus:
return None
# FIXME: dirty hack to workaround a bug in VLC snapshot
# functionality (unstability of the GUI when taking a snapshot
# < 100ms)
if (self.current_position_value <= 100 and
(config.data.os == 'win32' or config.data.os == 'darwin')):
print "Snapshots <=100ms dropped"
return None
s=self.mc.snapshot(position)
return s
def set_visual(self, xid):
if xid:
self.mc.set_visual(xid)
def sound_mute(self):
if self.mute_volume is None:
self.mute_volume=self.sound_get_volume()
self.sound_set_volume(0)
return
def sound_unmute(self):
if self.mute_volume is not None:
self.sound_set_volume(self.mute_volume)
self.mute_volume=None
return
def sound_is_muted(self):
return (self.mute_volume is not None)
advene-1.0/lib/advene/player/gstrecorder.py 0000644 0001752 0001752 00000027061 11672132267 020722 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
"""Gstreamer recorder interface.
Based on gst >= 0.10 API.
"""
import tempfile
import time
import advene.core.config as config
import gobject
gobject.threads_init()
try:
import pygst
pygst.require('0.10')
import gst
except ImportError:
gst=None
import os
name="GStreamer video recorder"
def register(controller=None):
if gst is None:
return False
controller.register_player(Player)
return True
class StreamInformation:
def __init__(self):
self.streamstatus=None
self.url=""
self.position=0
self.length=0
class Position:
def __init__(self, value=0):
self.value=value
# See Player attributes below...
self.origin=0
self.key=2
def __str__(self):
return "Position " + str(self.value)
class PositionKeyNotSupported(Exception):
pass
class PositionOrigin(Exception):
pass
class InvalidPosition(Exception):
pass
class PlaylistException(Exception):
pass
class InternalException(Exception):
pass
# Placeholder
class Caption:
pass
class Player:
player_id='gstrecorder'
player_capabilities=[ 'record' ]
# Class attributes
AbsolutePosition=0
RelativePosition=1
ModuloPosition=2
ByteCount=0
SampleCount=1
MediaTime=2
# Status
PlayingStatus=0
PauseStatus=1
InitStatus=2
EndStatus=3
UndefinedStatus=4
PositionKeyNotSupported=Exception("Position key not supported")
PositionOriginNotSupported=Exception("Position origin not supported")
InvalidPosition=Exception("Invalid position")
PlaylistException=Exception("Playlist error")
InternalException=Exception("Internal player error")
def __init__(self):
self.mute_volume=None
self.player=None
self.pipeline=None
self.videofile=time.strftime("/tmp/advene_record-%Y%m%d-%H%M%S.ogg")
self.build_pipeline()
self.status=Player.UndefinedStatus
self.current_position_value = 0
self.stream_duration = 0 # 60 * 60 * 1000
self.relative_position=self.create_position(0,
origin=self.RelativePosition)
self.position_update()
def build_pipeline(self):
if self.videofile is None:
return
videofile=self.videofile
if config.data.player['audio-record-device'] not in ('default', ''):
audiosrc = 'alsasrc device=' + config.data.player['audio-record-device']
else:
audiosrc = 'alsasrc'
videosrc='autovideosrc'
videosink='autovideosink'
if not config.data.player['record-video']:
# Generate black image
videosrc = 'videotestsrc pattern=2'
self.pipeline=gst.parse_launch('%(videosrc)s name=videosrc ! video/x-raw-yuv,width=352,pixel-aspect-ratio=(fraction)1/1 ! queue ! tee name=tee ! ffmpegcolorspace ! theoraenc drop-frames=1 ! queue ! oggmux name=mux ! filesink location=%(videofile)s %(audiosrc)s name=audiosrc ! audioconvert ! audiorate ! queue ! vorbisenc quality=0.5 ! mux. tee. ! queue ! %(videosink)s name=sink sync=false' % locals())
self.imagesink=self.pipeline.get_by_name('sink')
self.videosrc=self.pipeline.get_by_name('videosrc')
self.audiosrc=self.pipeline.get_by_name('audiosrc')
self.player=self.pipeline
# Asynchronous XOverlay support.
bus = self.pipeline.get_bus()
bus.enable_sync_message_emission()
def on_sync_message(bus, message):
if message.structure is None:
return
if message.structure.get_name() == 'prepare-xwindow-id' and self.xid is not None:
message.src.set_xwindow_id(self.xid)
if hasattr(message.src.props, 'force-aspect-ratio'):
message.src.set_property("force-aspect-ratio", True)
bus.connect('sync-message::element', on_sync_message)
def position2value(self, p):
"""Returns a position in ms.
"""
if isinstance(p, Position):
v=p.value
if p.key != self.MediaTime:
print "gstrecorder: unsupported key ", p.key
return 0
if p.origin != self.AbsolutePosition:
v += self.current_position()
else:
v=p
return long(v)
def current_status(self):
if self.player is None:
return self.UndefinedStatus
st=self.player.get_state()[1]
if st == gst.STATE_PLAYING:
return self.PlayingStatus
elif st == gst.STATE_PAUSED:
return self.PauseStatus
else:
return self.UndefinedStatus
def current_position(self):
"""Returns the current position in ms.
"""
if self.player is None:
return 0
try:
pos, format = self.player.query_position(gst.FORMAT_TIME)
except:
position = 0
else:
position = pos * 1.0 / gst.MSECOND
return position
def dvd_uri(self, title=None, chapter=None):
return ""
def check_uri(self):
return True
def log(self, *p):
print "gstrecorder player: %s" % p
def get_media_position(self, origin, key):
return self.current_position()
def set_media_position(self, position):
# No navigation
return
def start(self, position=None):
if self.current_status() == self.PlayingStatus:
# Already started
return
self.videofile=time.strftime("/tmp/advene_record-%Y%m%d-%H%M%S.ogg")
self.build_pipeline()
if self.player is None:
return
self.player.set_state(gst.STATE_PLAYING)
def pause(self, position=None):
# Ignore
return
def resume(self, position=None):
# Ignore
return
def stop(self, position=None):
self.stream_duration=self.current_position
if self.player is None:
return
self.player.set_state(gst.STATE_NULL)
def exit(self):
if self.player is None:
return
self.player.set_state(gst.STATE_NULL)
def playlist_add_item(self, item):
if item is None:
self.videofile=tempfile.mktemp('.ogg', 'record_')
elif os.path.exists(item):
# tempfile.mktemp should not be used for security reasons.
# But the probability of a tempfile attack against Advene
# is rather low at the time of writing this comment.
self.videofile=tempfile.mktemp('.ogg', 'record_')
print "%s already exists. We will not overwrite, so use %s instead " % (item, self.videofile)
else:
self.videofile=item
self.build_pipeline()
def playlist_clear(self):
self.videofile=None
def playlist_get_list(self):
if self.videofile is None:
return [ ]
else:
return [ self.videofile ]
def snapshot(self, position):
return None
def all_snapshots(self):
self.log("all_snapshots %s")
return [ None ]
def display_text (self, message, begin, end):
self.log("Display text", message)
def get_stream_information(self):
s=StreamInformation()
if self.videofile:
s.url=''
else:
s.url=self.videofile
s.position=self.current_position()
# Round length to the nearest second. This way, the timeline
# should correctly update.
s.length=s.position / 1000 * 1000
s.status=self.current_status()
return s
def sound_get_volume(self):
"""Get the current volume.
The result is a long value in [0, 100]
"""
# FIXME: should handle this properly
return 50
def sound_set_volume(self, v):
return 50
# Helper methods
def create_position (self, value=0, key=None, origin=None):
"""Create a Position.
"""
if key is None:
key=self.MediaTime
if origin is None:
origin=self.AbsolutePosition
p=Position()
p.value = value
p.origin = origin
p.key = key
return p
def update_status (self, status=None, position=None):
"""Update the player status.
Defined status:
- C{start}
- C{pause}
- C{resume}
- C{stop}
- C{set}
If no status is given, it only updates the value of self.status
If C{position} is None, it will be considered as zero for the
"start" action, and as the current relative position for other
actions.
@param status: the new status
@type status: string
@param position: the position
@type position: long
"""
#print "gstrec - update_status ", status, str(position)
# We only handle "start" and "stop".
if status == "start":
self.position_update()
if self.status not in (self.PlayingStatus, self.PauseStatus):
self.start()
elif status == "stop":
self.stop ()
self.position_update ()
def is_active(self):
return True
def check_player(self):
print "check player"
return True
def position_update(self):
s = self.get_stream_information ()
self.status = s.status
self.stream_duration = s.length
self.current_position_value = long(s.position)
def set_visual(self, xid):
self.xid = xid
if self.imagesink.implements_interface(gst.interfaces.XOverlay):
realsink = autovideosink.get_by_interface(gst.interfaces.XOverlay)
if realsink:
realsink.set_xwindow_id(self.xid)
if hasattr(realsink.props, 'force-aspect-ratio'):
realsink.set_property('force-aspect-ratio', True)
return True
def restart_player(self):
# FIXME: destroy the previous player
self.player.set_state(gst.STATE_READY)
# Rebuilt the pipeline
self.build_pipeline()
self.playlist_add_item(self.videofile)
self.position_update()
return True
def sound_mute(self):
if self.mute_volume is None:
self.mute_volume=self.sound_get_volume()
self.sound_set_volume(0)
return
def sound_unmute(self):
if self.mute_volume is not None:
self.sound_set_volume(self.mute_volume)
self.mute_volume=None
return
def sound_is_muted(self):
return (self.mute_volume is not None)
def disp(self, e, indent=" "):
l=[str(e)]
if hasattr(e, 'elements'):
i=indent+" "
l.extend( [ self.disp(c, i) for c in e.elements() ])
return ("\n"+indent).join(l)
def fullscreen(self, *p):
# Not implemented
return
advene-1.0/lib/advene/player/__init__.py 0000644 0001752 0001752 00000001453 11341717672 020135 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
advene-1.0/lib/advene/player/vlc.py 0000644 0001752 0001752 00000674407 11672132267 017177 0 ustar oaubert oaubert #! /usr/bin/python
#
# Python ctypes bindings for VLC
# Copyright (C) 2009 the VideoLAN team
# $Id: $
#
# Authors: Olivier Aubert
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 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 General Public License for more details.
#
# You should have received a copy of the GNU 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.
#
"""This module provides bindings for the
U{libvlc} and
U{MediaControl} APIs.
You can find documentation at U{http://www.advene.org/download/python-ctypes/}.
Basically, the most important class is L{Instance}, which is used to
create a libvlc Instance. From this instance, you can then create
L{MediaPlayer} and L{MediaListPlayer} instances.
"""
import logging
import ctypes
import sys
build_date="Thu Jan 28 12:00:04 2010"
# Used for win32 and MacOS X
detected_plugin_path=None
if sys.platform == 'linux2':
dll=ctypes.CDLL('libvlc.so.2')
elif sys.platform == 'win32':
import ctypes.util
import os
detected_plugin_path=None
path=ctypes.util.find_library('libvlc.dll')
if path is None:
# Try to use registry settings
import _winreg
detected_plugin_path_found = None
subkey, name = 'Software\\VideoLAN\\VLC','InstallDir'
for hkey in _winreg.HKEY_LOCAL_MACHINE, _winreg.HKEY_CURRENT_USER:
try:
reg = _winreg.OpenKey(hkey, subkey)
detected_plugin_path_found, type_id = _winreg.QueryValueEx(reg, name)
_winreg.CloseKey(reg)
break
except _winreg.error:
pass
if detected_plugin_path_found:
detected_plugin_path = detected_plugin_path_found
else:
# Try a standard location.
p='c:\\Program Files\\VideoLAN\\VLC\\libvlc.dll'
if os.path.exists(p):
detected_plugin_path=os.path.dirname(p)
if detected_plugin_path is not None:
os.chdir(detected_plugin_path)
# If chdir failed, this will not work and raise an exception
path='libvlc.dll'
else:
detected_plugin_path=os.path.dirname(path)
dll=ctypes.CDLL(path)
elif sys.platform == 'darwin':
# FIXME: should find a means to configure path
d='/Applications/VLC.app'
import os
if os.path.exists(d):
dll=ctypes.CDLL(d+'/Contents/MacOS/lib/libvlc.2.dylib')
detected_plugin_path=d+'/Contents/MacOS/modules'
else:
# Hope some default path is set...
dll=ctypes.CDLL('libvlc.2.dylib')
#
# Generated enum types.
#
class EventType(ctypes.c_ulong):
""" libvlc_core
LibVLC Available Events
"""
_names={
1: 'MediaSubItemAdded',
2: 'MediaDurationChanged',
3: 'MediaPreparsedChanged',
4: 'MediaFreed',
5: 'MediaStateChanged',
6: 'MediaPlayerNothingSpecial',
7: 'MediaPlayerOpening',
8: 'MediaPlayerBuffering',
9: 'MediaPlayerPlaying',
10: 'MediaPlayerPaused',
11: 'MediaPlayerStopped',
12: 'MediaPlayerForward',
13: 'MediaPlayerBackward',
14: 'MediaPlayerEndReached',
15: 'MediaPlayerEncounteredError',
16: 'MediaPlayerTimeChanged',
17: 'MediaPlayerPositionChanged',
18: 'MediaPlayerSeekableChanged',
19: 'MediaPlayerPausableChanged',
20: 'MediaListItemAdded',
21: 'MediaListWillAddItem',
22: 'MediaListItemDeleted',
23: 'MediaListWillDeleteItem',
24: 'MediaListViewItemAdded',
25: 'MediaListViewWillAddItem',
26: 'MediaListViewItemDeleted',
27: 'MediaListViewWillDeleteItem',
28: 'MediaListPlayerPlayed',
29: 'MediaListPlayerNextItemSet',
30: 'MediaListPlayerStopped',
31: 'MediaDiscovererStarted',
32: 'MediaDiscovererEnded',
33: 'MediaPlayerTitleChanged',
34: 'MediaPlayerSnapshotTaken',
}
def __repr__(self):
return ".".join((self.__class__.__module__, self.__class__.__name__, self._names[self.value]))
def __eq__(self, other):
return ( (isinstance(other, ctypes.c_ulong) and self.value == other.value)
or (isinstance(other, (int, long)) and self.value == other ) )
def __ne__(self, other):
return not self.__eq__(other)
EventType.MediaSubItemAdded=EventType(1)
EventType.MediaDurationChanged=EventType(2)
EventType.MediaPreparsedChanged=EventType(3)
EventType.MediaFreed=EventType(4)
EventType.MediaStateChanged=EventType(5)
EventType.MediaPlayerNothingSpecial=EventType(6)
EventType.MediaPlayerOpening=EventType(7)
EventType.MediaPlayerBuffering=EventType(8)
EventType.MediaPlayerPlaying=EventType(9)
EventType.MediaPlayerPaused=EventType(10)
EventType.MediaPlayerStopped=EventType(11)
EventType.MediaPlayerForward=EventType(12)
EventType.MediaPlayerBackward=EventType(13)
EventType.MediaPlayerEndReached=EventType(14)
EventType.MediaPlayerEncounteredError=EventType(15)
EventType.MediaPlayerTimeChanged=EventType(16)
EventType.MediaPlayerPositionChanged=EventType(17)
EventType.MediaPlayerSeekableChanged=EventType(18)
EventType.MediaPlayerPausableChanged=EventType(19)
EventType.MediaListItemAdded=EventType(20)
EventType.MediaListWillAddItem=EventType(21)
EventType.MediaListItemDeleted=EventType(22)
EventType.MediaListWillDeleteItem=EventType(23)
EventType.MediaListViewItemAdded=EventType(24)
EventType.MediaListViewWillAddItem=EventType(25)
EventType.MediaListViewItemDeleted=EventType(26)
EventType.MediaListViewWillDeleteItem=EventType(27)
EventType.MediaListPlayerPlayed=EventType(28)
EventType.MediaListPlayerNextItemSet=EventType(29)
EventType.MediaListPlayerStopped=EventType(30)
EventType.MediaDiscovererStarted=EventType(31)
EventType.MediaDiscovererEnded=EventType(32)
EventType.MediaPlayerTitleChanged=EventType(33)
EventType.MediaPlayerSnapshotTaken=EventType(34)
class Meta(ctypes.c_ulong):
""" libvlc_media
LibVLC Media Meta
"""
_names={
0: 'Title',
1: 'Artist',
2: 'Genre',
3: 'Copyright',
4: 'Album',
5: 'TrackNumber',
6: 'Description',
7: 'Rating',
8: 'Date',
9: 'Setting',
10: 'URL',
11: 'Language',
12: 'NowPlaying',
13: 'Publisher',
14: 'EncodedBy',
15: 'ArtworkURL',
16: 'TrackID',
}
def __repr__(self):
return ".".join((self.__class__.__module__, self.__class__.__name__, self._names[self.value]))
def __eq__(self, other):
return ( (isinstance(other, ctypes.c_ulong) and self.value == other.value)
or (isinstance(other, (int, long)) and self.value == other ) )
def __ne__(self, other):
return not self.__eq__(other)
Meta.Title=Meta(0)
Meta.Artist=Meta(1)
Meta.Genre=Meta(2)
Meta.Copyright=Meta(3)
Meta.Album=Meta(4)
Meta.TrackNumber=Meta(5)
Meta.Description=Meta(6)
Meta.Rating=Meta(7)
Meta.Date=Meta(8)
Meta.Setting=Meta(9)
Meta.URL=Meta(10)
Meta.Language=Meta(11)
Meta.NowPlaying=Meta(12)
Meta.Publisher=Meta(13)
Meta.EncodedBy=Meta(14)
Meta.ArtworkURL=Meta(15)
Meta.TrackID=Meta(16)
class State(ctypes.c_ulong):
"""Note the order of libvlc_state_t enum must match exactly the order of
See mediacontrol_PlayerStatus, See input_state_e enums,
and VideoLAN.LibVLC.State (at bindings/cil/src/media.cs).
Expected states by web plugins are:
IDLE/CLOSE=0, OPENING=1, BUFFERING=2, PLAYING=3, PAUSED=4,
STOPPING=5, ENDED=6, ERROR=7
"""
_names={
0: 'NothingSpecial',
1: 'Opening',
2: 'Buffering',
3: 'Playing',
4: 'Paused',
5: 'Stopped',
6: 'Ended',
7: 'Error',
}
def __repr__(self):
return ".".join((self.__class__.__module__, self.__class__.__name__, self._names[self.value]))
def __eq__(self, other):
return ( (isinstance(other, ctypes.c_ulong) and self.value == other.value)
or (isinstance(other, (int, long)) and self.value == other ) )
def __ne__(self, other):
return not self.__eq__(other)
State.NothingSpecial=State(0)
State.Opening=State(1)
State.Buffering=State(2)
State.Playing=State(3)
State.Paused=State(4)
State.Stopped=State(5)
State.Ended=State(6)
State.Error=State(7)
class AudioOutputDeviceTypes(ctypes.c_ulong):
"""Audio device types
"""
_names={
-1: 'Error',
1: 'Mono',
2: 'Stereo',
4: '_2F2R',
5: '_3F2R',
6: '_5_1',
7: '_6_1',
8: '_7_1',
10: 'SPDIF',
}
def __repr__(self):
return ".".join((self.__class__.__module__, self.__class__.__name__, self._names[self.value]))
def __eq__(self, other):
return ( (isinstance(other, ctypes.c_ulong) and self.value == other.value)
or (isinstance(other, (int, long)) and self.value == other ) )
def __ne__(self, other):
return not self.__eq__(other)
AudioOutputDeviceTypes.Error=AudioOutputDeviceTypes(-1)
AudioOutputDeviceTypes.Mono=AudioOutputDeviceTypes(1)
AudioOutputDeviceTypes.Stereo=AudioOutputDeviceTypes(2)
AudioOutputDeviceTypes._2F2R=AudioOutputDeviceTypes(4)
AudioOutputDeviceTypes._3F2R=AudioOutputDeviceTypes(5)
AudioOutputDeviceTypes._5_1=AudioOutputDeviceTypes(6)
AudioOutputDeviceTypes._6_1=AudioOutputDeviceTypes(7)
AudioOutputDeviceTypes._7_1=AudioOutputDeviceTypes(8)
AudioOutputDeviceTypes.SPDIF=AudioOutputDeviceTypes(10)
class AudioOutputChannel(ctypes.c_ulong):
"""Audio channels
"""
_names={
-1: 'Error',
1: 'Stereo',
2: 'RStereo',
3: 'Left',
4: 'Right',
5: 'Dolbys',
}
def __repr__(self):
return ".".join((self.__class__.__module__, self.__class__.__name__, self._names[self.value]))
def __eq__(self, other):
return ( (isinstance(other, ctypes.c_ulong) and self.value == other.value)
or (isinstance(other, (int, long)) and self.value == other ) )
def __ne__(self, other):
return not self.__eq__(other)
AudioOutputChannel.Error=AudioOutputChannel(-1)
AudioOutputChannel.Stereo=AudioOutputChannel(1)
AudioOutputChannel.RStereo=AudioOutputChannel(2)
AudioOutputChannel.Left=AudioOutputChannel(3)
AudioOutputChannel.Right=AudioOutputChannel(4)
AudioOutputChannel.Dolbys=AudioOutputChannel(5)
class PositionOrigin(ctypes.c_ulong):
"""A position may have different origins:
- absolute counts from the movie start
- relative counts from the current position
- modulo counts from the current position and wraps at the end of the movie
"""
_names={
0: 'AbsolutePosition',
1: 'RelativePosition',
2: 'ModuloPosition',
}
def __repr__(self):
return ".".join((self.__class__.__module__, self.__class__.__name__, self._names[self.value]))
def __eq__(self, other):
return ( (isinstance(other, ctypes.c_ulong) and self.value == other.value)
or (isinstance(other, (int, long)) and self.value == other ) )
def __ne__(self, other):
return not self.__eq__(other)
PositionOrigin.AbsolutePosition=PositionOrigin(0)
PositionOrigin.RelativePosition=PositionOrigin(1)
PositionOrigin.ModuloPosition=PositionOrigin(2)
class PositionKey(ctypes.c_ulong):
"""Units available in mediacontrol Positions
- ByteCount number of bytes
- SampleCount number of frames
- MediaTime time in milliseconds
"""
_names={
0: 'ByteCount',
1: 'SampleCount',
2: 'MediaTime',
}
def __repr__(self):
return ".".join((self.__class__.__module__, self.__class__.__name__, self._names[self.value]))
def __eq__(self, other):
return ( (isinstance(other, ctypes.c_ulong) and self.value == other.value)
or (isinstance(other, (int, long)) and self.value == other ) )
def __ne__(self, other):
return not self.__eq__(other)
PositionKey.ByteCount=PositionKey(0)
PositionKey.SampleCount=PositionKey(1)
PositionKey.MediaTime=PositionKey(2)
class PlayerStatus(ctypes.c_ulong):
"""Possible player status
Note the order of these enums must match exactly the order of
libvlc_state_t and input_state_e enums.
"""
_names={
0: 'UndefinedStatus',
1: 'InitStatus',
2: 'BufferingStatus',
3: 'PlayingStatus',
4: 'PauseStatus',
5: 'StopStatus',
6: 'EndStatus',
7: 'ErrorStatus',
}
def __repr__(self):
return ".".join((self.__class__.__module__, self.__class__.__name__, self._names[self.value]))
def __eq__(self, other):
return ( (isinstance(other, ctypes.c_ulong) and self.value == other.value)
or (isinstance(other, (int, long)) and self.value == other ) )
def __ne__(self, other):
return not self.__eq__(other)
PlayerStatus.UndefinedStatus=PlayerStatus(0)
PlayerStatus.InitStatus=PlayerStatus(1)
PlayerStatus.BufferingStatus=PlayerStatus(2)
PlayerStatus.PlayingStatus=PlayerStatus(3)
PlayerStatus.PauseStatus=PlayerStatus(4)
PlayerStatus.StopStatus=PlayerStatus(5)
PlayerStatus.EndStatus=PlayerStatus(6)
PlayerStatus.ErrorStatus=PlayerStatus(7)
#
# End of generated enum types.
#
class ListPOINTER(object):
'''Just like a POINTER but accept a list of ctype as an argument.
'''
def __init__(self, etype):
self.etype = etype
def from_param(self, param):
if isinstance(param, (list, tuple)):
return (self.etype * len(param))(*param)
class LibVLCException(Exception):
"""Python exception raised by libvlc methods.
"""
pass
# From libvlc_structures.h
# This is version-dependent, depending on the presence of libvlc_errmsg
if hasattr(dll, 'libvlc_errmsg'):
# New-style message passing
class VLCException(ctypes.Structure):
"""libvlc exception.
"""
_fields_= [
('raised', ctypes.c_int),
]
@property
def message(self):
return dll.libvlc_errmsg()
def init(self):
libvlc_exception_init(self)
def clear(self):
libvlc_exception_clear(self)
else:
# Old-style exceptions
class VLCException(ctypes.Structure):
"""libvlc exception.
"""
_fields_= [
('raised', ctypes.c_int),
('code', ctypes.c_int),
('message', ctypes.c_char_p),
]
def init(self):
libvlc_exception_init(self)
def clear(self):
libvlc_exception_clear(self)
class MediaStats(ctypes.Structure):
_fields_= [
('read_bytes', ctypes.c_int ),
('input_bitrate', ctypes.c_float),
('demux_read_bytes', ctypes.c_int ),
('demux_bitrate', ctypes.c_float),
('demux_corrupted', ctypes.c_int ),
('demux_discontinuity', ctypes.c_int ),
('decoded_video', ctypes.c_int ),
('decoded_audio', ctypes.c_int ),
('displayed_pictures', ctypes.c_int ),
('lost_pictures', ctypes.c_int ),
('played_abuffers', ctypes.c_int ),
('lost_abuffers', ctypes.c_int ),
('sent_packets', ctypes.c_int ),
('sent_bytes', ctypes.c_int ),
('send_bitrate', ctypes.c_float),
]
def __str__(self):
return "MediaStats\n%s" % "\n".join( "%s:\t%s" % (n, getattr(self, n)) for n in self._fields_ )
if 'EsType' in dir():
class MediaES(ctypes.Structure):
_fields_= [
('codec' , ctypes.c_uint32),
('id' , ctypes.c_int),
('type' , EsType),
('profile' , ctypes.c_int),
('level' , ctypes.c_int),
('channels', ctypes.c_uint),
('rate' , ctypes.c_uint),
('height' , ctypes.c_uint),
('width' , ctypes.c_uint),
]
def __str__(self):
return "MediaES \n%s" % "\n".join( "%s:\t%s" % (n, getattr(self, n)) for n in self._fields_ )
class PlaylistItem(ctypes.Structure):
_fields_= [
('id', ctypes.c_int),
('uri', ctypes.c_char_p),
('name', ctypes.c_char_p),
]
def __str__(self):
return "PlaylistItem #%d %s (%uri)" % (self.id, self.name, self.uri)
class LogMessage(ctypes.Structure):
_fields_= [
('size', ctypes.c_uint),
('severity', ctypes.c_int),
('type', ctypes.c_char_p),
('name', ctypes.c_char_p),
('header', ctypes.c_char_p),
('message', ctypes.c_char_p),
]
def __init__(self):
super(LogMessage, self).__init__()
self.size=ctypes.sizeof(self)
def __str__(self):
return "vlc.LogMessage(%d:%s): %s" % (self.severity, self.type, self.message)
class MediaControlPosition(ctypes.Structure):
_fields_= [
('origin', PositionOrigin),
('key', PositionKey),
('value', ctypes.c_longlong),
]
def __init__(self, value=0, origin=None, key=None):
# We override the __init__ method so that instanciating the
# class with an int as parameter will create the appropriate
# default position (absolute position, media time, with the
# int as value).
super(MediaControlPosition, self).__init__()
self.value=value
if origin is None:
origin=PositionOrigin.AbsolutePosition
if key is None:
key=PositionKey.MediaTime
self.origin=origin
self.key=key
def __str__(self):
return "MediaControlPosition %ld (%s, %s)" % (
self.value,
str(self.origin),
str(self.key)
)
@staticmethod
def from_param(arg):
if isinstance(arg, (int, long)):
return MediaControlPosition(arg)
else:
return arg
class MediaControlException(ctypes.Structure):
_fields_= [
('code', ctypes.c_int),
('message', ctypes.c_char_p),
]
def init(self):
mediacontrol_exception_init(self)
def clear(self):
mediacontrol_exception_free(self)
class MediaControlStreamInformation(ctypes.Structure):
_fields_= [
('status', PlayerStatus),
('url', ctypes.c_char_p),
('position', ctypes.c_longlong),
('length', ctypes.c_longlong),
]
def __str__(self):
return "%s (%s) : %ld / %ld" % (self.url or "",
str(self.status),
self.position,
self.length)
class RGBPicture(ctypes.Structure):
_fields_= [
('width', ctypes.c_int),
('height', ctypes.c_int),
('type', ctypes.c_uint32),
('date', ctypes.c_ulonglong),
('size', ctypes.c_int),
('data_pointer', ctypes.c_void_p),
]
@property
def data(self):
return ctypes.string_at(self.data_pointer, self.size)
def __str__(self):
return "RGBPicture (%d, %d) - %ld ms - %d bytes" % (self.width, self.height, self.date, self.size)
def free(self):
mediacontrol_RGBPicture__free(self)
def check_vlc_exception(result, func, args):
"""Error checking method for functions using an exception in/out parameter.
"""
ex=args[-1]
if not isinstance(ex, (VLCException, MediaControlException)):
logging.warn("python-vlc: error when processing function %s. Please report this as a bug to vlc-devel@videolan.org" % str(func))
return result
# Take into account both VLCException and MediacontrolException:
c=getattr(ex, 'raised', getattr(ex, 'code', 0))
if c:
raise LibVLCException(ex.message)
return result
### End of header.py ###
class AudioOutput(object):
def __new__(cls, pointer=None):
'''Internal method used for instanciating wrappers from ctypes.
'''
if pointer is None:
raise Exception("Internal method. Surely this class cannot be instanciated by itself.")
if pointer == 0:
return None
else:
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(pointer)
return o
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
if hasattr(dll, 'libvlc_audio_output_list_release'):
def list_release(self):
"""Free the list of available audio outputs
"""
return libvlc_audio_output_list_release(self)
class EventManager(object):
def __new__(cls, pointer=None):
'''Internal method used for instanciating wrappers from ctypes.
'''
if pointer is None:
raise Exception("Internal method. Surely this class cannot be instanciated by itself.")
if pointer == 0:
return None
else:
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(pointer)
return o
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
if hasattr(dll, 'libvlc_event_attach'):
def event_attach(self, i_event_type, f_callback, user_data):
"""Register for an event notification.
@param i_event_type: the desired event to which we want to listen
@param f_callback: the function to call when i_event_type occurs
@param user_data: user provided data to carry with the event
"""
e=VLCException()
return libvlc_event_attach(self, i_event_type, f_callback, user_data, e)
if hasattr(dll, 'libvlc_event_detach'):
def event_detach(self, i_event_type, f_callback, p_user_data):
"""Unregister an event notification.
@param i_event_type: the desired event to which we want to unregister
@param f_callback: the function to call when i_event_type occurs
@param p_user_data: user provided data to carry with the event
"""
e=VLCException()
return libvlc_event_detach(self, i_event_type, f_callback, p_user_data, e)
class Instance(object):
"""Create a new Instance instance.
It may take as parameter either:
- a string
- a list of strings as first parameters
- the parameters given as the constructor parameters (must be strings)
- a MediaControl instance
"""
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
def __new__(cls, *p):
if p and p[0] == 0:
return None
elif p and isinstance(p[0], (int, long)):
# instance creation from ctypes
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(p[0])
return o
elif len(p) == 1 and isinstance(p[0], basestring):
# Only 1 string parameter: should be a parameter line
p=p[0].split(' ')
elif len(p) == 1 and isinstance(p[0], (tuple, list)):
p=p[0]
if p and isinstance(p[0], MediaControl):
return p[0].get_instance()
else:
if not p and detected_plugin_path is not None:
# No parameters passed. Under win32 and MacOS, specify
# the detected_plugin_path if present.
p=[ 'vlc', '--plugin-path='+ detected_plugin_path ]
e=VLCException()
return libvlc_new(len(p), p, e)
def media_player_new(self, uri=None):
"""Create a new Media Player object.
@param uri: an optional URI to play in the player.
"""
e=VLCException()
p=libvlc_media_player_new(self, e)
if uri:
p.set_media(self.media_new(uri))
p._instance=self
return p
def media_list_player_new(self):
"""Create an empty Media Player object
"""
e=VLCException()
p=libvlc_media_list_player_new(self, e)
p._instance=self
return p
def media_new(self, mrl, *options):
"""Create an empty Media Player object
Options can be specified as supplementary string parameters, e.g.
m=i.media_new('foo.avi', 'sub-filter=marq{marquee=Hello}', 'vout-filter=invert')
"""
e=VLCException()
m=libvlc_media_new(self, mrl, e)
for o in options:
libvlc_media_add_option(m, o, e)
return m
if hasattr(dll, 'libvlc_get_vlc_id'):
def get_vlc_id(self):
"""Return a libvlc instance identifier for legacy APIs. Use of this
function is discouraged, you should convert your program to use the
new API.
@return: the instance identifier
"""
return libvlc_get_vlc_id(self)
if hasattr(dll, 'libvlc_release'):
def release(self):
"""Decrement the reference count of a libvlc instance, and destroy it
if it reaches zero.
"""
return libvlc_release(self)
if hasattr(dll, 'libvlc_retain'):
def retain(self):
"""Increments the reference count of a libvlc instance.
The initial reference count is 1 after libvlc_new() returns.
"""
return libvlc_retain(self)
if hasattr(dll, 'libvlc_add_intf'):
def add_intf(self, name):
"""Try to start a user interface for the libvlc instance.
@param name: interface name, or NULL for default
"""
e=VLCException()
return libvlc_add_intf(self, name, e)
if hasattr(dll, 'libvlc_wait'):
def wait(self):
"""Waits until an interface causes the instance to exit.
You should start at least one interface first, using libvlc_add_intf().
"""
return libvlc_wait(self)
if hasattr(dll, 'libvlc_get_log_verbosity'):
def get_log_verbosity(self):
"""Return the VLC messaging verbosity level.
@return: verbosity level for messages
"""
e=VLCException()
return libvlc_get_log_verbosity(self, e)
if hasattr(dll, 'libvlc_set_log_verbosity'):
def set_log_verbosity(self, level):
"""Set the VLC messaging verbosity level.
@param level: log level
"""
e=VLCException()
return libvlc_set_log_verbosity(self, level, e)
if hasattr(dll, 'libvlc_log_open'):
def log_open(self):
"""Open a VLC message log instance.
@return: log message instance
"""
e=VLCException()
return libvlc_log_open(self, e)
if hasattr(dll, 'libvlc_media_new_as_node'):
def media_new_as_node(self, psz_name):
"""Create a media as an empty node with the passed name.
@param psz_name: the name of the node
@return: the new empty media
"""
e=VLCException()
return libvlc_media_new_as_node(self, psz_name, e)
if hasattr(dll, 'libvlc_media_discoverer_new_from_name'):
def media_discoverer_new_from_name(self, psz_name):
"""Discover media service by name.
@param psz_name: service name
@return: media discover object
"""
e=VLCException()
return libvlc_media_discoverer_new_from_name(self, psz_name, e)
if hasattr(dll, 'libvlc_media_library_new'):
def media_library_new(self):
"""\ingroup libvlc
LibVLC Media Library
"""
e=VLCException()
return libvlc_media_library_new(self, e)
if hasattr(dll, 'libvlc_media_list_new'):
def media_list_new(self):
"""Create an empty media list.
@return: empty media list
"""
e=VLCException()
return libvlc_media_list_new(self, e)
if hasattr(dll, 'libvlc_audio_output_list_get'):
def audio_output_list_get(self):
"""Get the list of available audio outputs
@return: list of available audio outputs, at the end free it with
"""
e=VLCException()
return libvlc_audio_output_list_get(self, e)
if hasattr(dll, 'libvlc_audio_output_set'):
def audio_output_set(self, psz_name):
"""Set the audio output.
Change will be applied after stop and play.
@return: true if function succeded
"""
return libvlc_audio_output_set(self, psz_name)
if hasattr(dll, 'libvlc_audio_output_device_count'):
def audio_output_device_count(self, psz_audio_output):
"""Get count of devices for audio output, these devices are hardware oriented
like analor or digital output of sound card
@return: number of devices
"""
return libvlc_audio_output_device_count(self, psz_audio_output)
if hasattr(dll, 'libvlc_audio_output_device_longname'):
def audio_output_device_longname(self, psz_audio_output, i_device):
"""Get long name of device, if not available short name given
@param psz_audio_output: - name of audio output, \see libvlc_audio_output_t
@return: long name of device
"""
return libvlc_audio_output_device_longname(self, psz_audio_output, i_device)
if hasattr(dll, 'libvlc_audio_output_device_id'):
def audio_output_device_id(self, psz_audio_output, i_device):
"""Get id name of device
@param psz_audio_output: - name of audio output, \see libvlc_audio_output_t
@return: id name of device, use for setting device, need to be free after use
"""
return libvlc_audio_output_device_id(self, psz_audio_output, i_device)
if hasattr(dll, 'libvlc_audio_output_device_set'):
def audio_output_device_set(self, psz_audio_output, psz_device_id):
"""Set device for using
@param psz_audio_output: - name of audio output, \see libvlc_audio_output_t
"""
return libvlc_audio_output_device_set(self, psz_audio_output, psz_device_id)
if hasattr(dll, 'libvlc_audio_output_get_device_type'):
def audio_output_get_device_type(self):
"""Get current audio device type. Device type describes something like
character of output sound - stereo sound, 2.1, 5.1 etc
@return: the audio devices type \see libvlc_audio_output_device_types_t
"""
e=VLCException()
return libvlc_audio_output_get_device_type(self, e)
if hasattr(dll, 'libvlc_audio_output_set_device_type'):
def audio_output_set_device_type(self, device_type):
"""Set current audio device type.
@param device_type: the audio device type,
"""
e=VLCException()
return libvlc_audio_output_set_device_type(self, device_type, e)
if hasattr(dll, 'libvlc_audio_toggle_mute'):
def audio_toggle_mute(self):
"""Toggle mute status.
"""
e=VLCException()
return libvlc_audio_toggle_mute(self, e)
if hasattr(dll, 'libvlc_audio_get_mute'):
def audio_get_mute(self):
"""Get current mute status.
@return: the mute status (boolean)
"""
e=VLCException()
return libvlc_audio_get_mute(self, e)
if hasattr(dll, 'libvlc_audio_set_mute'):
def audio_set_mute(self, status):
"""Set mute status.
@param status: If status is true then mute, otherwise unmute
"""
e=VLCException()
return libvlc_audio_set_mute(self, status, e)
if hasattr(dll, 'libvlc_audio_get_volume'):
def audio_get_volume(self):
"""Get current audio level.
@return: the audio level (int)
"""
e=VLCException()
return libvlc_audio_get_volume(self, e)
if hasattr(dll, 'libvlc_audio_set_volume'):
def audio_set_volume(self, i_volume):
"""Set current audio level.
@param i_volume: the volume (int)
"""
e=VLCException()
return libvlc_audio_set_volume(self, i_volume, e)
if hasattr(dll, 'libvlc_audio_get_channel'):
def audio_get_channel(self):
"""Get current audio channel.
@return: the audio channel \see libvlc_audio_output_channel_t
"""
e=VLCException()
return libvlc_audio_get_channel(self, e)
if hasattr(dll, 'libvlc_audio_set_channel'):
def audio_set_channel(self, channel):
"""Set current audio channel.
@param channel: the audio channel, \see libvlc_audio_output_channel_t
"""
e=VLCException()
return libvlc_audio_set_channel(self, channel, e)
if hasattr(dll, 'libvlc_vlm_release'):
def vlm_release(self):
"""Release the vlm instance related to the given libvlc_instance_t
"""
e=VLCException()
return libvlc_vlm_release(self, e)
if hasattr(dll, 'libvlc_vlm_add_broadcast'):
def vlm_add_broadcast(self, psz_name, psz_input, psz_output, i_options, ppsz_options, b_enabled, b_loop):
"""Add a broadcast, with one input.
@param psz_name: the name of the new broadcast
@param psz_input: the input MRL
@param psz_output: the output MRL (the parameter to the "sout" variable)
@param i_options: number of additional options
@param ppsz_options: additional options
@param b_enabled: boolean for enabling the new broadcast
@param b_loop: Should this broadcast be played in loop ?
"""
e=VLCException()
return libvlc_vlm_add_broadcast(self, psz_name, psz_input, psz_output, i_options, ppsz_options, b_enabled, b_loop, e)
if hasattr(dll, 'libvlc_vlm_add_vod'):
def vlm_add_vod(self, psz_name, psz_input, i_options, ppsz_options, b_enabled, psz_mux):
"""Add a vod, with one input.
@param psz_name: the name of the new vod media
@param psz_input: the input MRL
@param i_options: number of additional options
@param ppsz_options: additional options
@param b_enabled: boolean for enabling the new vod
@param psz_mux: the muxer of the vod media
"""
e=VLCException()
return libvlc_vlm_add_vod(self, psz_name, psz_input, i_options, ppsz_options, b_enabled, psz_mux, e)
if hasattr(dll, 'libvlc_vlm_del_media'):
def vlm_del_media(self, psz_name):
"""Delete a media (VOD or broadcast).
@param psz_name: the media to delete
"""
e=VLCException()
return libvlc_vlm_del_media(self, psz_name, e)
if hasattr(dll, 'libvlc_vlm_set_enabled'):
def vlm_set_enabled(self, psz_name, b_enabled):
"""Enable or disable a media (VOD or broadcast).
@param psz_name: the media to work on
@param b_enabled: the new status
"""
e=VLCException()
return libvlc_vlm_set_enabled(self, psz_name, b_enabled, e)
if hasattr(dll, 'libvlc_vlm_set_output'):
def vlm_set_output(self, psz_name, psz_output):
"""Set the output for a media.
@param psz_name: the media to work on
@param psz_output: the output MRL (the parameter to the "sout" variable)
"""
e=VLCException()
return libvlc_vlm_set_output(self, psz_name, psz_output, e)
if hasattr(dll, 'libvlc_vlm_set_input'):
def vlm_set_input(self, psz_name, psz_input):
"""Set a media's input MRL. This will delete all existing inputs and
add the specified one.
@param psz_name: the media to work on
@param psz_input: the input MRL
"""
e=VLCException()
return libvlc_vlm_set_input(self, psz_name, psz_input, e)
if hasattr(dll, 'libvlc_vlm_add_input'):
def vlm_add_input(self, psz_name, psz_input):
"""Add a media's input MRL. This will add the specified one.
@param psz_name: the media to work on
@param psz_input: the input MRL
"""
e=VLCException()
return libvlc_vlm_add_input(self, psz_name, psz_input, e)
if hasattr(dll, 'libvlc_vlm_set_loop'):
def vlm_set_loop(self, psz_name, b_loop):
"""Set a media's loop status.
@param psz_name: the media to work on
@param b_loop: the new status
"""
e=VLCException()
return libvlc_vlm_set_loop(self, psz_name, b_loop, e)
if hasattr(dll, 'libvlc_vlm_set_mux'):
def vlm_set_mux(self, psz_name, psz_mux):
"""Set a media's vod muxer.
@param psz_name: the media to work on
@param psz_mux: the new muxer
"""
e=VLCException()
return libvlc_vlm_set_mux(self, psz_name, psz_mux, e)
if hasattr(dll, 'libvlc_vlm_change_media'):
def vlm_change_media(self, psz_name, psz_input, psz_output, i_options, ppsz_options, b_enabled, b_loop):
"""Edit the parameters of a media. This will delete all existing inputs and
add the specified one.
@param psz_name: the name of the new broadcast
@param psz_input: the input MRL
@param psz_output: the output MRL (the parameter to the "sout" variable)
@param i_options: number of additional options
@param ppsz_options: additional options
@param b_enabled: boolean for enabling the new broadcast
@param b_loop: Should this broadcast be played in loop ?
"""
e=VLCException()
return libvlc_vlm_change_media(self, psz_name, psz_input, psz_output, i_options, ppsz_options, b_enabled, b_loop, e)
if hasattr(dll, 'libvlc_vlm_play_media'):
def vlm_play_media(self, psz_name):
"""Play the named broadcast.
@param psz_name: the name of the broadcast
"""
e=VLCException()
return libvlc_vlm_play_media(self, psz_name, e)
if hasattr(dll, 'libvlc_vlm_stop_media'):
def vlm_stop_media(self, psz_name):
"""Stop the named broadcast.
@param psz_name: the name of the broadcast
"""
e=VLCException()
return libvlc_vlm_stop_media(self, psz_name, e)
if hasattr(dll, 'libvlc_vlm_pause_media'):
def vlm_pause_media(self, psz_name):
"""Pause the named broadcast.
@param psz_name: the name of the broadcast
"""
e=VLCException()
return libvlc_vlm_pause_media(self, psz_name, e)
if hasattr(dll, 'libvlc_vlm_seek_media'):
def vlm_seek_media(self, psz_name, f_percentage):
"""Seek in the named broadcast.
@param psz_name: the name of the broadcast
@param f_percentage: the percentage to seek to
"""
e=VLCException()
return libvlc_vlm_seek_media(self, psz_name, f_percentage, e)
if hasattr(dll, 'libvlc_vlm_show_media'):
def vlm_show_media(self, psz_name):
"""Return information about the named broadcast.
\bug will always return NULL
@param psz_name: the name of the broadcast
@return: string with information about named media
"""
e=VLCException()
return libvlc_vlm_show_media(self, psz_name, e)
if hasattr(dll, 'libvlc_vlm_get_media_instance_position'):
def vlm_get_media_instance_position(self, psz_name, i_instance):
"""Get vlm_media instance position by name or instance id
@param psz_name: name of vlm media instance
@param i_instance: instance id
@return: position as float
"""
e=VLCException()
return libvlc_vlm_get_media_instance_position(self, psz_name, i_instance, e)
if hasattr(dll, 'libvlc_vlm_get_media_instance_time'):
def vlm_get_media_instance_time(self, psz_name, i_instance):
"""Get vlm_media instance time by name or instance id
@param psz_name: name of vlm media instance
@param i_instance: instance id
@return: time as integer
"""
e=VLCException()
return libvlc_vlm_get_media_instance_time(self, psz_name, i_instance, e)
if hasattr(dll, 'libvlc_vlm_get_media_instance_length'):
def vlm_get_media_instance_length(self, psz_name, i_instance):
"""Get vlm_media instance length by name or instance id
@param psz_name: name of vlm media instance
@param i_instance: instance id
@return: length of media item
"""
e=VLCException()
return libvlc_vlm_get_media_instance_length(self, psz_name, i_instance, e)
if hasattr(dll, 'libvlc_vlm_get_media_instance_rate'):
def vlm_get_media_instance_rate(self, psz_name, i_instance):
"""Get vlm_media instance playback rate by name or instance id
@param psz_name: name of vlm media instance
@param i_instance: instance id
@return: playback rate
"""
e=VLCException()
return libvlc_vlm_get_media_instance_rate(self, psz_name, i_instance, e)
if hasattr(dll, 'libvlc_vlm_get_media_instance_title'):
def vlm_get_media_instance_title(self, psz_name, i_instance):
"""Get vlm_media instance title number by name or instance id
\bug will always return 0
@param psz_name: name of vlm media instance
@param i_instance: instance id
@return: title as number
"""
e=VLCException()
return libvlc_vlm_get_media_instance_title(self, psz_name, i_instance, e)
if hasattr(dll, 'libvlc_vlm_get_media_instance_chapter'):
def vlm_get_media_instance_chapter(self, psz_name, i_instance):
"""Get vlm_media instance chapter number by name or instance id
\bug will always return 0
@param psz_name: name of vlm media instance
@param i_instance: instance id
@return: chapter as number
"""
e=VLCException()
return libvlc_vlm_get_media_instance_chapter(self, psz_name, i_instance, e)
if hasattr(dll, 'libvlc_vlm_get_media_instance_seekable'):
def vlm_get_media_instance_seekable(self, psz_name, i_instance):
"""Is libvlc instance seekable ?
\bug will always return 0
@param psz_name: name of vlm media instance
@param i_instance: instance id
@return: 1 if seekable, 0 if not
"""
e=VLCException()
return libvlc_vlm_get_media_instance_seekable(self, psz_name, i_instance, e)
if hasattr(dll, 'mediacontrol_new_from_instance'):
def mediacontrol_new_from_instance(self):
"""Create a MediaControl instance from an existing libvlc instance
@return: a mediacontrol_Instance
"""
e=MediaControlException()
return mediacontrol_new_from_instance(self, e)
class Log(object):
def __new__(cls, pointer=None):
'''Internal method used for instanciating wrappers from ctypes.
'''
if pointer is None:
raise Exception("Internal method. Surely this class cannot be instanciated by itself.")
if pointer == 0:
return None
else:
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(pointer)
return o
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
def __iter__(self):
return self.get_iterator()
def dump(self):
return [ str(m) for m in self ]
if hasattr(dll, 'libvlc_log_close'):
def close(self):
"""Close a VLC message log instance.
"""
e=VLCException()
return libvlc_log_close(self, e)
if hasattr(dll, 'libvlc_log_count'):
def count(self):
"""Returns the number of messages in a log instance.
@return: number of log messages
"""
e=VLCException()
return libvlc_log_count(self, e)
def __len__(self):
e=VLCException()
return libvlc_log_count(self, e)
if hasattr(dll, 'libvlc_log_clear'):
def clear(self):
"""Clear a log instance.
All messages in the log are removed. The log should be cleared on a
regular basis to avoid clogging.
"""
e=VLCException()
return libvlc_log_clear(self, e)
if hasattr(dll, 'libvlc_log_get_iterator'):
def get_iterator(self):
"""Allocate and returns a new iterator to messages in log.
@return: log iterator object
"""
e=VLCException()
return libvlc_log_get_iterator(self, e)
class LogIterator(object):
def __new__(cls, pointer=None):
'''Internal method used for instanciating wrappers from ctypes.
'''
if pointer is None:
raise Exception("Internal method. Surely this class cannot be instanciated by itself.")
if pointer == 0:
return None
else:
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(pointer)
return o
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
def __iter__(self):
return self
def next(self):
if not self.has_next():
raise StopIteration
buf=LogMessage()
e=VLCException()
ret=libvlc_log_iterator_next(self, buf, e)
return ret.contents
if hasattr(dll, 'libvlc_log_iterator_free'):
def free(self):
"""Release a previoulsy allocated iterator.
"""
e=VLCException()
return libvlc_log_iterator_free(self, e)
if hasattr(dll, 'libvlc_log_iterator_has_next'):
def has_next(self):
"""Return whether log iterator has more messages.
@return: true if iterator has more message objects, else false
"""
e=VLCException()
return libvlc_log_iterator_has_next(self, e)
class Media(object):
def __new__(cls, pointer=None):
'''Internal method used for instanciating wrappers from ctypes.
'''
if pointer is None:
raise Exception("Internal method. Surely this class cannot be instanciated by itself.")
if pointer == 0:
return None
else:
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(pointer)
return o
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
def add_options(self, *list_of_options):
"""Add a list of options to the media.
Options must be written without the double-dash, e.g.:
m.add_options('sub-filter=marq@test{marquee=Hello}', 'video-filter=invert')
Note that you also can directly pass these options in the Instance.media_new method:
m=instance.media_new( 'foo.avi', 'sub-filter=marq@test{marquee=Hello}', 'video-filter=invert')
"""
for o in list_of_options:
self.add_option(o)
if hasattr(dll, 'libvlc_media_add_option'):
def add_option(self, ppsz_options):
"""Add an option to the media.
This option will be used to determine how the media_player will
read the media. This allows to use VLC's advanced
reading/streaming options on a per-media basis.
The options are detailed in vlc --long-help, for instance "--sout-all"
@param ppsz_options: the options (as a string)
"""
e=VLCException()
return libvlc_media_add_option(self, ppsz_options, e)
if hasattr(dll, 'libvlc_media_add_option_untrusted'):
def add_option_untrusted(self, ppsz_options):
"""Add an option to the media from an untrusted source.
This option will be used to determine how the media_player will
read the media. This allows to use VLC's advanced
reading/streaming options on a per-media basis.
The options are detailed in vlc --long-help, for instance "--sout-all"
@param ppsz_options: the options (as a string)
"""
e=VLCException()
return libvlc_media_add_option_untrusted(self, ppsz_options, e)
if hasattr(dll, 'libvlc_media_retain'):
def retain(self):
"""Retain a reference to a media descriptor object (libvlc_media_t). Use
libvlc_media_release() to decrement the reference count of a
media descriptor object.
"""
return libvlc_media_retain(self)
if hasattr(dll, 'libvlc_media_release'):
def release(self):
"""Decrement the reference count of a media descriptor object. If the
reference count is 0, then libvlc_media_release() will release the
media descriptor object. It will send out an libvlc_MediaFreed event
to all listeners. If the media descriptor object has been released it
should not be used again.
"""
return libvlc_media_release(self)
if hasattr(dll, 'libvlc_media_get_mrl'):
def get_mrl(self):
"""Get the media resource locator (mrl) from a media descriptor object
@return: string with mrl of media descriptor object
"""
e=VLCException()
return libvlc_media_get_mrl(self, e)
if hasattr(dll, 'libvlc_media_duplicate'):
def duplicate(self):
"""Duplicate a media descriptor object.
"""
return libvlc_media_duplicate(self)
if hasattr(dll, 'libvlc_media_get_meta'):
def get_meta(self, e_meta):
"""Read the meta of the media.
@param e_meta: the meta to read
@return: the media's meta
"""
e=VLCException()
return libvlc_media_get_meta(self, e_meta, e)
if hasattr(dll, 'libvlc_media_get_state'):
def get_state(self):
"""Get current state of media descriptor object. Possible media states
are defined in libvlc_structures.c ( libvlc_NothingSpecial=0,
libvlc_Opening, libvlc_Buffering, libvlc_Playing, libvlc_Paused,
libvlc_Stopped, libvlc_Ended,
libvlc_Error).
See libvlc_state_t
@return: state of media descriptor object
"""
e=VLCException()
return libvlc_media_get_state(self, e)
if hasattr(dll, 'libvlc_media_subitems'):
def subitems(self):
"""Get subitems of media descriptor object. This will increment
the reference count of supplied media descriptor object. Use
libvlc_media_list_release() to decrement the reference counting.
@return: list of media descriptor subitems or NULL
"""
e=VLCException()
return libvlc_media_subitems(self, e)
if hasattr(dll, 'libvlc_media_event_manager'):
def event_manager(self):
"""Get event manager from media descriptor object.
NOTE: this function doesn't increment reference counting.
@return: event manager object
"""
e=VLCException()
return libvlc_media_event_manager(self, e)
if hasattr(dll, 'libvlc_media_get_duration'):
def get_duration(self):
"""Get duration of media descriptor object item.
@return: duration of media item
"""
e=VLCException()
return libvlc_media_get_duration(self, e)
if hasattr(dll, 'libvlc_media_is_preparsed'):
def is_preparsed(self):
"""Get preparsed status for media descriptor object.
@return: true if media object has been preparsed otherwise it returns false
"""
e=VLCException()
return libvlc_media_is_preparsed(self, e)
if hasattr(dll, 'libvlc_media_set_user_data'):
def set_user_data(self, p_new_user_data):
"""Sets media descriptor's user_data. user_data is specialized data
accessed by the host application, VLC.framework uses it as a pointer to
an native object that references a libvlc_media_t pointer
@param p_new_user_data: pointer to user data
"""
e=VLCException()
return libvlc_media_set_user_data(self, p_new_user_data, e)
if hasattr(dll, 'libvlc_media_get_user_data'):
def get_user_data(self):
"""Get media descriptor's user_data. user_data is specialized data
accessed by the host application, VLC.framework uses it as a pointer to
an native object that references a libvlc_media_t pointer
"""
e=VLCException()
return libvlc_media_get_user_data(self, e)
if hasattr(dll, 'libvlc_media_player_new_from_media'):
def player_new_from_media(self):
"""Create a Media Player object from a Media
"""
e=VLCException()
return libvlc_media_player_new_from_media(self, e)
class MediaControl(object):
"""Create a new MediaControl instance
It may take as parameter either:
- a string
- a list of strings as first parameters
- the parameters given as the constructor parameters (must be strings)
- a vlc.Instance
"""
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
def __new__(cls, *p):
if p and p[0] == 0:
return None
elif p and isinstance(p[0], (int, long)):
# instance creation from ctypes
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(p[0])
return o
elif len(p) == 1 and isinstance(p[0], basestring):
# Only 1 string parameter: should be a parameter line
p=p[0].split(' ')
elif len(p) == 1 and isinstance(p[0], (tuple, list)):
p=p[0]
if p and isinstance(p[0], Instance):
e=MediaControlException()
return mediacontrol_new_from_instance(p[0], e)
else:
if not p and detected_plugin_path is not None:
# No parameters passed. Under win32 and MacOS, specify
# the detected_plugin_path if present.
p=[ 'vlc', '--plugin-path='+ detected_plugin_path ]
e=MediaControlException()
return mediacontrol_new(len(p), p, e)
def get_media_position(self, origin=PositionOrigin.AbsolutePosition, key=PositionKey.MediaTime):
e=MediaControlException()
p=mediacontrol_get_media_position(self, origin, key, e)
if p:
return p.contents
else:
return None
def set_media_position(self, pos):
"""Set the media position.
@param pos: a MediaControlPosition or an integer (in ms)
"""
if not isinstance(pos, MediaControlPosition):
pos=MediaControlPosition(long(pos))
e=MediaControlException()
mediacontrol_set_media_position(self, pos, e)
def start(self, pos=0):
"""Start the player at the given position.
@param pos: a MediaControlPosition or an integer (in ms)
"""
if not isinstance(pos, MediaControlPosition):
pos=MediaControlPosition(long(pos))
e=MediaControlException()
mediacontrol_start(self, pos, e)
def snapshot(self, pos=0):
"""Take a snapshot.
Note: the position parameter is not properly implemented. For
the moment, the only valid position is the 0-relative position
(i.e. the current position).
@param pos: a MediaControlPosition or an integer (in ms)
"""
if not isinstance(pos, MediaControlPosition):
pos=MediaControlPosition(long(pos))
e=MediaControlException()
p=mediacontrol_snapshot(self, pos, e)
if p:
snap=p.contents
# FIXME: there is a bug in the current mediacontrol_snapshot
# implementation, which sets an incorrect date.
# Workaround here:
snap.date=self.get_media_position().value
return snap
else:
return None
def display_text(self, message='', begin=0, end=1000):
"""Display a caption between begin and end positions.
@param message: the caption to display
@param begin: the begin position
@param end: the end position
"""
if not isinstance(begin, MediaControlPosition):
begin=self.value2position(begin)
if not isinstance(end, MediaControlPosition):
end=self.value2position(end)
e=MediaControlException()
mediacontrol_display_text(self, message, begin, end, e)
def get_stream_information(self, key=PositionKey.MediaTime):
"""Return information about the stream.
"""
e=MediaControlException()
return mediacontrol_get_stream_information(self, key, e).contents
if hasattr(dll, 'mediacontrol_get_libvlc_instance'):
def get_instance(self):
"""Get the associated libvlc instance
@return: a libvlc instance
"""
return mediacontrol_get_libvlc_instance(self)
if hasattr(dll, 'mediacontrol_get_media_player'):
def get_media_player(self):
"""Get the associated libvlc_media_player
@return: a libvlc_media_player_t instance
"""
return mediacontrol_get_media_player(self)
if hasattr(dll, 'mediacontrol_pause'):
def pause(self):
"""Pause the movie at a given position
"""
e=MediaControlException()
return mediacontrol_pause(self, e)
if hasattr(dll, 'mediacontrol_resume'):
def resume(self):
"""Resume the movie at a given position
"""
e=MediaControlException()
return mediacontrol_resume(self, e)
if hasattr(dll, 'mediacontrol_stop'):
def stop(self):
"""Stop the movie at a given position
"""
e=MediaControlException()
return mediacontrol_stop(self, e)
if hasattr(dll, 'mediacontrol_exit'):
def exit(self):
"""Exit the player
"""
return mediacontrol_exit(self)
if hasattr(dll, 'mediacontrol_set_mrl'):
def set_mrl(self, psz_file):
"""Set the MRL to be played.
@param psz_file: the MRL
"""
e=MediaControlException()
return mediacontrol_set_mrl(self, psz_file, e)
if hasattr(dll, 'mediacontrol_get_mrl'):
def get_mrl(self):
"""Get the MRL to be played.
"""
e=MediaControlException()
return mediacontrol_get_mrl(self, e)
if hasattr(dll, 'mediacontrol_sound_get_volume'):
def sound_get_volume(self):
"""Get the current audio level, normalized in [0..100]
@return: the volume
"""
e=MediaControlException()
return mediacontrol_sound_get_volume(self, e)
if hasattr(dll, 'mediacontrol_sound_set_volume'):
def sound_set_volume(self, volume):
"""Set the audio level
@param volume: the volume (normalized in [0..100])
"""
e=MediaControlException()
return mediacontrol_sound_set_volume(self, volume, e)
if hasattr(dll, 'mediacontrol_set_visual'):
def set_visual(self, visual_id):
"""Set the video output window
@param visual_id: the Xid or HWND, depending on the platform
"""
e=MediaControlException()
return mediacontrol_set_visual(self, visual_id, e)
if hasattr(dll, 'mediacontrol_get_rate'):
def get_rate(self):
"""Get the current playing rate, in percent
@return: the rate
"""
e=MediaControlException()
return mediacontrol_get_rate(self, e)
if hasattr(dll, 'mediacontrol_set_rate'):
def set_rate(self, rate):
"""Set the playing rate, in percent
@param rate: the desired rate
"""
e=MediaControlException()
return mediacontrol_set_rate(self, rate, e)
if hasattr(dll, 'mediacontrol_get_fullscreen'):
def get_fullscreen(self):
"""Get current fullscreen status
@return: the fullscreen status
"""
e=MediaControlException()
return mediacontrol_get_fullscreen(self, e)
if hasattr(dll, 'mediacontrol_set_fullscreen'):
def set_fullscreen(self, b_fullscreen):
"""Set fullscreen status
@param b_fullscreen: the desired status
"""
e=MediaControlException()
return mediacontrol_set_fullscreen(self, b_fullscreen, e)
class MediaDiscoverer(object):
def __new__(cls, pointer=None):
'''Internal method used for instanciating wrappers from ctypes.
'''
if pointer is None:
raise Exception("Internal method. Surely this class cannot be instanciated by itself.")
if pointer == 0:
return None
else:
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(pointer)
return o
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
if hasattr(dll, 'libvlc_media_discoverer_release'):
def release(self):
"""Release media discover object. If the reference count reaches 0, then
the object will be released.
"""
return libvlc_media_discoverer_release(self)
if hasattr(dll, 'libvlc_media_discoverer_localized_name'):
def localized_name(self):
"""Get media service discover object its localized name.
@return: localized name
"""
return libvlc_media_discoverer_localized_name(self)
if hasattr(dll, 'libvlc_media_discoverer_media_list'):
def media_list(self):
"""Get media service discover media list.
@return: list of media items
"""
return libvlc_media_discoverer_media_list(self)
if hasattr(dll, 'libvlc_media_discoverer_event_manager'):
def event_manager(self):
"""Get event manager from media service discover object.
@return: event manager object.
"""
return libvlc_media_discoverer_event_manager(self)
if hasattr(dll, 'libvlc_media_discoverer_is_running'):
def is_running(self):
"""Query if media service discover object is running.
@return: true if running, false if not
"""
return libvlc_media_discoverer_is_running(self)
class MediaLibrary(object):
def __new__(cls, pointer=None):
'''Internal method used for instanciating wrappers from ctypes.
'''
if pointer is None:
raise Exception("Internal method. Surely this class cannot be instanciated by itself.")
if pointer == 0:
return None
else:
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(pointer)
return o
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
if hasattr(dll, 'libvlc_media_library_release'):
def release(self):
"""Release media library object. This functions decrements the
reference count of the media library object. If it reaches 0,
then the object will be released.
"""
return libvlc_media_library_release(self)
if hasattr(dll, 'libvlc_media_library_retain'):
def retain(self):
"""Retain a reference to a media library object. This function will
increment the reference counting for this object. Use
libvlc_media_library_release() to decrement the reference count.
"""
return libvlc_media_library_retain(self)
if hasattr(dll, 'libvlc_media_library_load'):
def load(self):
"""Load media library.
"""
e=VLCException()
return libvlc_media_library_load(self, e)
if hasattr(dll, 'libvlc_media_library_save'):
def save(self):
"""Save media library.
"""
e=VLCException()
return libvlc_media_library_save(self, e)
if hasattr(dll, 'libvlc_media_library_media_list'):
def media_list(self):
"""Get media library subitems.
@return: media list subitems
"""
e=VLCException()
return libvlc_media_library_media_list(self, e)
class MediaList(object):
def __new__(cls, pointer=None):
'''Internal method used for instanciating wrappers from ctypes.
'''
if pointer is None:
raise Exception("Internal method. Surely this class cannot be instanciated by itself.")
if pointer == 0:
return None
else:
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(pointer)
return o
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
if hasattr(dll, 'libvlc_media_list_release'):
def release(self):
"""Release media list created with libvlc_media_list_new().
"""
return libvlc_media_list_release(self)
if hasattr(dll, 'libvlc_media_list_retain'):
def retain(self):
"""Retain reference to a media list
"""
return libvlc_media_list_retain(self)
if hasattr(dll, 'libvlc_media_list_set_media'):
def set_media(self, p_mi):
"""Associate media instance with this media list instance.
If another media instance was present it will be released.
The libvlc_media_list_lock should NOT be held upon entering this function.
@param p_mi: media instance to add
"""
e=VLCException()
return libvlc_media_list_set_media(self, p_mi, e)
if hasattr(dll, 'libvlc_media_list_media'):
def media(self):
"""Get media instance from this media list instance. This action will increase
the refcount on the media instance.
The libvlc_media_list_lock should NOT be held upon entering this function.
@return: media instance
"""
e=VLCException()
return libvlc_media_list_media(self, e)
if hasattr(dll, 'libvlc_media_list_add_media'):
def add_media(self, p_mi):
"""Add media instance to media list
The libvlc_media_list_lock should be held upon entering this function.
@param p_mi: a media instance
"""
e=VLCException()
return libvlc_media_list_add_media(self, p_mi, e)
if hasattr(dll, 'libvlc_media_list_insert_media'):
def insert_media(self, p_mi, i_pos):
"""Insert media instance in media list on a position
The libvlc_media_list_lock should be held upon entering this function.
@param p_mi: a media instance
@param i_pos: position in array where to insert
"""
e=VLCException()
return libvlc_media_list_insert_media(self, p_mi, i_pos, e)
if hasattr(dll, 'libvlc_media_list_remove_index'):
def remove_index(self, i_pos):
"""Remove media instance from media list on a position
The libvlc_media_list_lock should be held upon entering this function.
@param i_pos: position in array where to insert
"""
e=VLCException()
return libvlc_media_list_remove_index(self, i_pos, e)
if hasattr(dll, 'libvlc_media_list_count'):
def count(self):
"""Get count on media list items
The libvlc_media_list_lock should be held upon entering this function.
@return: number of items in media list
"""
e=VLCException()
return libvlc_media_list_count(self, e)
def __len__(self):
e=VLCException()
return libvlc_media_list_count(self, e)
if hasattr(dll, 'libvlc_media_list_item_at_index'):
def item_at_index(self, i_pos):
"""List media instance in media list at a position
The libvlc_media_list_lock should be held upon entering this function.
@param i_pos: position in array where to insert
@return: media instance at position i_pos and libvlc_media_retain() has been called to increase the refcount on this object.
"""
e=VLCException()
return libvlc_media_list_item_at_index(self, i_pos, e)
def __getitem__(self, i):
e=VLCException()
return libvlc_media_list_item_at_index(self, i, e)
def __iter__(self):
e=VLCException()
for i in xrange(len(self)):
yield self[i]
if hasattr(dll, 'libvlc_media_list_index_of_item'):
def index_of_item(self, p_mi):
"""Find index position of List media instance in media list.
Warning: the function will return the first matched position.
The libvlc_media_list_lock should be held upon entering this function.
@param p_mi: media list instance
@return: position of media instance
"""
e=VLCException()
return libvlc_media_list_index_of_item(self, p_mi, e)
if hasattr(dll, 'libvlc_media_list_is_readonly'):
def is_readonly(self):
"""This indicates if this media list is read-only from a user point of view
@return: 0 on readonly, 1 on readwrite
"""
return libvlc_media_list_is_readonly(self)
if hasattr(dll, 'libvlc_media_list_lock'):
def lock(self):
"""Get lock on media list items
"""
return libvlc_media_list_lock(self)
if hasattr(dll, 'libvlc_media_list_unlock'):
def unlock(self):
"""Release lock on media list items
The libvlc_media_list_lock should be held upon entering this function.
"""
return libvlc_media_list_unlock(self)
if hasattr(dll, 'libvlc_media_list_flat_view'):
def flat_view(self):
"""Get a flat media list view of media list items
@return: flat media list view instance
"""
e=VLCException()
return libvlc_media_list_flat_view(self, e)
if hasattr(dll, 'libvlc_media_list_hierarchical_view'):
def hierarchical_view(self):
"""Get a hierarchical media list view of media list items
@return: hierarchical media list view instance
"""
e=VLCException()
return libvlc_media_list_hierarchical_view(self, e)
if hasattr(dll, 'libvlc_media_list_hierarchical_node_view'):
def hierarchical_node_view(self):
"""
"""
e=VLCException()
return libvlc_media_list_hierarchical_node_view(self, e)
if hasattr(dll, 'libvlc_media_list_event_manager'):
def event_manager(self):
"""Get libvlc_event_manager from this media list instance.
The p_event_manager is immutable, so you don't have to hold the lock
@return: libvlc_event_manager
"""
e=VLCException()
return libvlc_media_list_event_manager(self, e)
class MediaListPlayer(object):
"""Create a new MediaPlayer instance.
It may take as parameter either:
- a vlc.Instance
- nothing
"""
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
def __new__(cls, *p):
if p and p[0] == 0:
return None
elif p and isinstance(p[0], (int, long)):
# instance creation from ctypes
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(p[0])
return o
elif len(p) == 1 and isinstance(p[0], (tuple, list)):
p=p[0]
if p and isinstance(p[0], Instance):
return p[0].media_list_player_new()
else:
i=Instance()
o=i.media_list_player_new()
return o
def get_instance(self):
"""Return the associated vlc.Instance.
"""
return self._instance
if hasattr(dll, 'libvlc_media_list_player_release'):
def release(self):
"""Release media_list_player.
"""
return libvlc_media_list_player_release(self)
if hasattr(dll, 'libvlc_media_list_player_set_media_player'):
def set_media_player(self, p_mi):
"""Replace media player in media_list_player with this instance.
@param p_mi: media player instance
"""
e=VLCException()
return libvlc_media_list_player_set_media_player(self, p_mi, e)
if hasattr(dll, 'libvlc_media_list_player_set_media_list'):
def set_media_list(self, p_mlist):
"""
"""
e=VLCException()
return libvlc_media_list_player_set_media_list(self, p_mlist, e)
if hasattr(dll, 'libvlc_media_list_player_play'):
def play(self):
"""Play media list
"""
e=VLCException()
return libvlc_media_list_player_play(self, e)
if hasattr(dll, 'libvlc_media_list_player_pause'):
def pause(self):
"""Pause media list
"""
e=VLCException()
return libvlc_media_list_player_pause(self, e)
if hasattr(dll, 'libvlc_media_list_player_is_playing'):
def is_playing(self):
"""Is media list playing?
@return: true for playing and false for not playing
"""
e=VLCException()
return libvlc_media_list_player_is_playing(self, e)
if hasattr(dll, 'libvlc_media_list_player_get_state'):
def get_state(self):
"""Get current libvlc_state of media list player
@return: libvlc_state_t for media list player
"""
e=VLCException()
return libvlc_media_list_player_get_state(self, e)
if hasattr(dll, 'libvlc_media_list_player_play_item_at_index'):
def play_item_at_index(self, i_index):
"""Play media list item at position index
@param i_index: index in media list to play
"""
e=VLCException()
return libvlc_media_list_player_play_item_at_index(self, i_index, e)
def __getitem__(self, i):
e=VLCException()
return libvlc_media_list_player_play_item_at_index(self, i, e)
def __iter__(self):
e=VLCException()
for i in xrange(len(self)):
yield self[i]
if hasattr(dll, 'libvlc_media_list_player_play_item'):
def play_item(self, p_md):
"""
"""
e=VLCException()
return libvlc_media_list_player_play_item(self, p_md, e)
if hasattr(dll, 'libvlc_media_list_player_stop'):
def stop(self):
"""Stop playing media list
"""
e=VLCException()
return libvlc_media_list_player_stop(self, e)
if hasattr(dll, 'libvlc_media_list_player_next'):
def next(self):
"""Play next item from media list
"""
e=VLCException()
return libvlc_media_list_player_next(self, e)
class MediaListView(object):
def __new__(cls, pointer=None):
'''Internal method used for instanciating wrappers from ctypes.
'''
if pointer is None:
raise Exception("Internal method. Surely this class cannot be instanciated by itself.")
if pointer == 0:
return None
else:
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(pointer)
return o
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
if hasattr(dll, 'libvlc_media_list_view_retain'):
def retain(self):
"""Retain reference to a media list view
"""
return libvlc_media_list_view_retain(self)
if hasattr(dll, 'libvlc_media_list_view_release'):
def release(self):
"""Release reference to a media list view. If the refcount reaches 0, then
the object will be released.
"""
return libvlc_media_list_view_release(self)
if hasattr(dll, 'libvlc_media_list_view_event_manager'):
def event_manager(self):
"""Get libvlc_event_manager from this media list view instance.
The p_event_manager is immutable, so you don't have to hold the lock
@return: libvlc_event_manager
"""
return libvlc_media_list_view_event_manager(self)
if hasattr(dll, 'libvlc_media_list_view_count'):
def count(self):
"""Get count on media list view items
@return: number of items in media list view
"""
e=VLCException()
return libvlc_media_list_view_count(self, e)
def __len__(self):
e=VLCException()
return libvlc_media_list_view_count(self, e)
if hasattr(dll, 'libvlc_media_list_view_item_at_index'):
def item_at_index(self, i_index):
"""List media instance in media list view at an index position
@param i_index: index position in array where to insert
@return: media instance at position i_pos and libvlc_media_retain() has been called to increase the refcount on this object.
"""
e=VLCException()
return libvlc_media_list_view_item_at_index(self, i_index, e)
def __getitem__(self, i):
e=VLCException()
return libvlc_media_list_view_item_at_index(self, i, e)
def __iter__(self):
e=VLCException()
for i in xrange(len(self)):
yield self[i]
if hasattr(dll, 'libvlc_media_list_view_children_at_index'):
def children_at_index(self, index):
"""
"""
e=VLCException()
return libvlc_media_list_view_children_at_index(self, index, e)
if hasattr(dll, 'libvlc_media_list_view_children_for_item'):
def children_for_item(self, p_md):
"""
"""
e=VLCException()
return libvlc_media_list_view_children_for_item(self, p_md, e)
if hasattr(dll, 'libvlc_media_list_view_parent_media_list'):
def parent_media_list(self):
"""
"""
e=VLCException()
return libvlc_media_list_view_parent_media_list(self, e)
class MediaPlayer(object):
"""Create a new MediaPlayer instance.
It may take as parameter either:
- a string (media URI). In this case, a vlc.Instance will be created.
- a vlc.Instance
"""
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
def __new__(cls, *p):
if p and p[0] == 0:
return None
elif p and isinstance(p[0], (int, long)):
# instance creation from ctypes
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(p[0])
return o
if p and isinstance(p[0], Instance):
return p[0].media_player_new()
else:
i=Instance()
o=i.media_player_new()
if p:
o.set_media(i.media_new(p[0]))
return o
def get_instance(self):
"""Return the associated vlc.Instance.
"""
return self._instance
if hasattr(dll, 'libvlc_media_player_release'):
def release(self):
"""Release a media_player after use
Decrement the reference count of a media player object. If the
reference count is 0, then libvlc_media_player_release() will
release the media player object. If the media player object
has been released, then it should not be used again.
"""
return libvlc_media_player_release(self)
if hasattr(dll, 'libvlc_media_player_retain'):
def retain(self):
"""Retain a reference to a media player object. Use
libvlc_media_player_release() to decrement reference count.
"""
return libvlc_media_player_retain(self)
if hasattr(dll, 'libvlc_media_player_set_media'):
def set_media(self, p_md):
"""Set the media that will be used by the media_player. If any,
previous md will be released.
@param p_md: the Media. Afterwards the p_md can be safely
"""
e=VLCException()
return libvlc_media_player_set_media(self, p_md, e)
if hasattr(dll, 'libvlc_media_player_get_media'):
def get_media(self):
"""Get the media used by the media_player.
@return: the media associated with p_mi, or NULL if no
"""
e=VLCException()
return libvlc_media_player_get_media(self, e)
if hasattr(dll, 'libvlc_media_player_event_manager'):
def event_manager(self):
"""Get the Event Manager from which the media player send event.
@return: the event manager associated with p_mi
"""
e=VLCException()
return libvlc_media_player_event_manager(self, e)
if hasattr(dll, 'libvlc_media_player_is_playing'):
def is_playing(self):
"""is_playing
@return: 1 if the media player is playing, 0 otherwise
"""
e=VLCException()
return libvlc_media_player_is_playing(self, e)
if hasattr(dll, 'libvlc_media_player_play'):
def play(self):
"""Play
"""
e=VLCException()
return libvlc_media_player_play(self, e)
if hasattr(dll, 'libvlc_media_player_pause'):
def pause(self):
"""Pause
"""
e=VLCException()
return libvlc_media_player_pause(self, e)
if hasattr(dll, 'libvlc_media_player_stop'):
def stop(self):
"""Stop
"""
e=VLCException()
return libvlc_media_player_stop(self, e)
if hasattr(dll, 'libvlc_media_player_set_nsobject'):
def set_nsobject(self, drawable):
"""Set the agl handler where the media player should render its video output.
@param drawable: the agl handler
"""
e=VLCException()
return libvlc_media_player_set_nsobject(self, drawable, e)
if hasattr(dll, 'libvlc_media_player_get_nsobject'):
def get_nsobject(self):
"""Get the agl handler previously set with libvlc_media_player_set_agl().
@return: the agl handler or 0 if none where set
"""
return libvlc_media_player_get_nsobject(self)
if hasattr(dll, 'libvlc_media_player_set_agl'):
def set_agl(self, drawable):
"""Set the agl handler where the media player should render its video output.
@param drawable: the agl handler
"""
e=VLCException()
return libvlc_media_player_set_agl(self, drawable, e)
if hasattr(dll, 'libvlc_media_player_get_agl'):
def get_agl(self):
"""Get the agl handler previously set with libvlc_media_player_set_agl().
@return: the agl handler or 0 if none where set
"""
return libvlc_media_player_get_agl(self)
if hasattr(dll, 'libvlc_media_player_set_xwindow'):
def set_xwindow(self, drawable):
"""Set an X Window System drawable where the media player should render its
video output. If LibVLC was built without X11 output support, then this has
no effects.
The specified identifier must correspond to an existing Input/Output class
X11 window. Pixmaps are not supported. The caller shall ensure that
the X11 server is the same as the one the VLC instance has been configured
with.
If XVideo is not used, it is assumed that the drawable has the
following properties in common with the default X11 screen: depth, scan line
pad, black pixel. This is a bug.
@param drawable: the ID of the X window
"""
e=VLCException()
return libvlc_media_player_set_xwindow(self, drawable, e)
if hasattr(dll, 'libvlc_media_player_get_xwindow'):
def get_xwindow(self):
"""Get the X Window System window identifier previously set with
libvlc_media_player_set_xwindow(). Note that this will return the identifier
even if VLC is not currently using it (for instance if it is playing an
audio-only input).
@return: an X window ID, or 0 if none where set.
"""
return libvlc_media_player_get_xwindow(self)
if hasattr(dll, 'libvlc_media_player_set_hwnd'):
def set_hwnd(self, drawable):
"""Set a Win32/Win64 API window handle (HWND) where the media player should
render its video output. If LibVLC was built without Win32/Win64 API output
support, then this has no effects.
@param drawable: windows handle of the drawable
"""
e=VLCException()
return libvlc_media_player_set_hwnd(self, drawable, e)
if hasattr(dll, 'libvlc_media_player_get_hwnd'):
def get_hwnd(self):
"""Get the Windows API window handle (HWND) previously set with
libvlc_media_player_set_hwnd(). The handle will be returned even if LibVLC
is not currently outputting any video to it.
@return: a window handle or NULL if there are none.
"""
return libvlc_media_player_get_hwnd(self)
if hasattr(dll, 'libvlc_media_player_get_length'):
def get_length(self):
"""Get the current movie length (in ms).
@return: the movie length (in ms).
"""
e=VLCException()
return libvlc_media_player_get_length(self, e)
if hasattr(dll, 'libvlc_media_player_get_time'):
def get_time(self):
"""Get the current movie time (in ms).
@return: the movie time (in ms).
"""
e=VLCException()
return libvlc_media_player_get_time(self, e)
if hasattr(dll, 'libvlc_media_player_set_time'):
def set_time(self, the):
"""Set the movie time (in ms).
@param the: movie time (in ms).
"""
e=VLCException()
return libvlc_media_player_set_time(self, the, e)
if hasattr(dll, 'libvlc_media_player_get_position'):
def get_position(self):
"""Get movie position.
@return: movie position
"""
e=VLCException()
return libvlc_media_player_get_position(self, e)
if hasattr(dll, 'libvlc_media_player_set_position'):
def set_position(self, f_pos):
"""Set movie position.
@param f_pos: the position
"""
e=VLCException()
return libvlc_media_player_set_position(self, f_pos, e)
if hasattr(dll, 'libvlc_media_player_set_chapter'):
def set_chapter(self, i_chapter):
"""Set movie chapter
@param i_chapter: chapter number to play
"""
e=VLCException()
return libvlc_media_player_set_chapter(self, i_chapter, e)
if hasattr(dll, 'libvlc_media_player_get_chapter'):
def get_chapter(self):
"""Get movie chapter
@return: chapter number currently playing
"""
e=VLCException()
return libvlc_media_player_get_chapter(self, e)
if hasattr(dll, 'libvlc_media_player_get_chapter_count'):
def get_chapter_count(self):
"""Get movie chapter count
@return: number of chapters in movie
"""
e=VLCException()
return libvlc_media_player_get_chapter_count(self, e)
if hasattr(dll, 'libvlc_media_player_will_play'):
def will_play(self):
"""Will the player play
@return: boolean
"""
e=VLCException()
return libvlc_media_player_will_play(self, e)
if hasattr(dll, 'libvlc_media_player_get_chapter_count_for_title'):
def get_chapter_count_for_title(self, i_title):
"""Get title chapter count
@param i_title: title
@return: number of chapters in title
"""
e=VLCException()
return libvlc_media_player_get_chapter_count_for_title(self, i_title, e)
if hasattr(dll, 'libvlc_media_player_set_title'):
def set_title(self, i_title):
"""Set movie title
@param i_title: title number to play
"""
e=VLCException()
return libvlc_media_player_set_title(self, i_title, e)
if hasattr(dll, 'libvlc_media_player_get_title'):
def get_title(self):
"""Get movie title
@return: title number currently playing
"""
e=VLCException()
return libvlc_media_player_get_title(self, e)
if hasattr(dll, 'libvlc_media_player_get_title_count'):
def get_title_count(self):
"""Get movie title count
@return: title number count
"""
e=VLCException()
return libvlc_media_player_get_title_count(self, e)
if hasattr(dll, 'libvlc_media_player_previous_chapter'):
def previous_chapter(self):
"""Set previous chapter
"""
e=VLCException()
return libvlc_media_player_previous_chapter(self, e)
if hasattr(dll, 'libvlc_media_player_next_chapter'):
def next_chapter(self):
"""Set next chapter
"""
e=VLCException()
return libvlc_media_player_next_chapter(self, e)
if hasattr(dll, 'libvlc_media_player_get_rate'):
def get_rate(self):
"""Get movie play rate
@return: movie play rate
"""
e=VLCException()
return libvlc_media_player_get_rate(self, e)
if hasattr(dll, 'libvlc_media_player_set_rate'):
def set_rate(self, movie):
"""Set movie play rate
@param movie: play rate to set
"""
e=VLCException()
return libvlc_media_player_set_rate(self, movie, e)
if hasattr(dll, 'libvlc_media_player_get_state'):
def get_state(self):
"""Get current movie state
@return: current movie state as libvlc_state_t
"""
e=VLCException()
return libvlc_media_player_get_state(self, e)
if hasattr(dll, 'libvlc_media_player_get_fps'):
def get_fps(self):
"""Get movie fps rate
@return: frames per second (fps) for this playing movie
"""
e=VLCException()
return libvlc_media_player_get_fps(self, e)
if hasattr(dll, 'libvlc_media_player_has_vout'):
def has_vout(self):
"""Does this media player have a video output?
"""
e=VLCException()
return libvlc_media_player_has_vout(self, e)
if hasattr(dll, 'libvlc_media_player_is_seekable'):
def is_seekable(self):
"""Is this media player seekable?
"""
e=VLCException()
return libvlc_media_player_is_seekable(self, e)
if hasattr(dll, 'libvlc_media_player_can_pause'):
def can_pause(self):
"""Can this media player be paused?
"""
e=VLCException()
return libvlc_media_player_can_pause(self, e)
if hasattr(dll, 'libvlc_toggle_fullscreen'):
def toggle_fullscreen(self):
"""Toggle fullscreen status on video output.
"""
e=VLCException()
return libvlc_toggle_fullscreen(self, e)
if hasattr(dll, 'libvlc_set_fullscreen'):
def set_fullscreen(self, b_fullscreen):
"""Enable or disable fullscreen on a video output.
@param b_fullscreen: boolean for fullscreen status
"""
e=VLCException()
return libvlc_set_fullscreen(self, b_fullscreen, e)
if hasattr(dll, 'libvlc_get_fullscreen'):
def get_fullscreen(self):
"""Get current fullscreen status.
@return: the fullscreen status (boolean)
"""
e=VLCException()
return libvlc_get_fullscreen(self, e)
if hasattr(dll, 'libvlc_video_get_height'):
def video_get_height(self):
"""Get current video height.
@return: the video height
"""
e=VLCException()
return libvlc_video_get_height(self, e)
if hasattr(dll, 'libvlc_video_get_width'):
def video_get_width(self):
"""Get current video width.
@return: the video width
"""
e=VLCException()
return libvlc_video_get_width(self, e)
if hasattr(dll, 'libvlc_video_get_scale'):
def video_get_scale(self):
"""Get the current video scaling factor.
See also libvlc_video_set_scale().
@return: the currently configured zoom factor, or 0. if the video is set
"""
e=VLCException()
return libvlc_video_get_scale(self, e)
if hasattr(dll, 'libvlc_video_set_scale'):
def video_set_scale(self, i_factor):
"""Set the video scaling factor. That is the ratio of the number of pixels on
screen to the number of pixels in the original decoded video in each
dimension. Zero is a special value; it will adjust the video to the output
window/drawable (in windowed mode) or the entire screen.
Note that not all video outputs support scaling.
@param i_factor: the scaling factor, or zero
"""
e=VLCException()
return libvlc_video_set_scale(self, i_factor, e)
if hasattr(dll, 'libvlc_video_get_aspect_ratio'):
def video_get_aspect_ratio(self):
"""Get current video aspect ratio.
@return: the video aspect ratio
"""
e=VLCException()
return libvlc_video_get_aspect_ratio(self, e)
if hasattr(dll, 'libvlc_video_set_aspect_ratio'):
def video_set_aspect_ratio(self, psz_aspect):
"""Set new video aspect ratio.
@param psz_aspect: new video aspect-ratio
"""
e=VLCException()
return libvlc_video_set_aspect_ratio(self, psz_aspect, e)
if hasattr(dll, 'libvlc_video_get_spu'):
def video_get_spu(self):
"""Get current video subtitle.
@return: the video subtitle selected
"""
e=VLCException()
return libvlc_video_get_spu(self, e)
if hasattr(dll, 'libvlc_video_get_spu_count'):
def video_get_spu_count(self):
"""Get the number of available video subtitles.
@return: the number of available video subtitles
"""
e=VLCException()
return libvlc_video_get_spu_count(self, e)
if hasattr(dll, 'libvlc_video_get_spu_description'):
def video_get_spu_description(self):
"""Get the description of available video subtitles.
@return: list containing description of available video subtitles
"""
e=VLCException()
return libvlc_video_get_spu_description(self, e)
if hasattr(dll, 'libvlc_video_set_spu'):
def video_set_spu(self, i_spu):
"""Set new video subtitle.
@param i_spu: new video subtitle to select
"""
e=VLCException()
return libvlc_video_set_spu(self, i_spu, e)
if hasattr(dll, 'libvlc_video_set_subtitle_file'):
def video_set_subtitle_file(self, psz_subtitle):
"""Set new video subtitle file.
@param psz_subtitle: new video subtitle file
@return: the success status (boolean)
"""
e=VLCException()
return libvlc_video_set_subtitle_file(self, psz_subtitle, e)
if hasattr(dll, 'libvlc_video_get_title_description'):
def video_get_title_description(self):
"""Get the description of available titles.
@return: list containing description of available titles
"""
e=VLCException()
return libvlc_video_get_title_description(self, e)
if hasattr(dll, 'libvlc_video_get_chapter_description'):
def video_get_chapter_description(self, i_title):
"""Get the description of available chapters for specific title.
@param i_title: selected title
@return: list containing description of available chapter for title i_title
"""
e=VLCException()
return libvlc_video_get_chapter_description(self, i_title, e)
if hasattr(dll, 'libvlc_video_get_crop_geometry'):
def video_get_crop_geometry(self):
"""Get current crop filter geometry.
@return: the crop filter geometry
"""
e=VLCException()
return libvlc_video_get_crop_geometry(self, e)
if hasattr(dll, 'libvlc_video_set_crop_geometry'):
def video_set_crop_geometry(self, psz_geometry):
"""Set new crop filter geometry.
@param psz_geometry: new crop filter geometry
"""
e=VLCException()
return libvlc_video_set_crop_geometry(self, psz_geometry, e)
if hasattr(dll, 'libvlc_toggle_teletext'):
def toggle_teletext(self):
"""Toggle teletext transparent status on video output.
"""
e=VLCException()
return libvlc_toggle_teletext(self, e)
if hasattr(dll, 'libvlc_video_get_teletext'):
def video_get_teletext(self):
"""Get current teletext page requested.
@return: the current teletext page requested.
"""
e=VLCException()
return libvlc_video_get_teletext(self, e)
if hasattr(dll, 'libvlc_video_set_teletext'):
def video_set_teletext(self, i_page):
"""Set new teletext page to retrieve.
@param i_page: teletex page number requested
"""
e=VLCException()
return libvlc_video_set_teletext(self, i_page, e)
if hasattr(dll, 'libvlc_video_get_track_count'):
def video_get_track_count(self):
"""Get number of available video tracks.
@return: the number of available video tracks (int)
"""
e=VLCException()
return libvlc_video_get_track_count(self, e)
if hasattr(dll, 'libvlc_video_get_track_description'):
def video_get_track_description(self):
"""Get the description of available video tracks.
@return: list with description of available video tracks
"""
e=VLCException()
return libvlc_video_get_track_description(self, e)
if hasattr(dll, 'libvlc_video_get_track'):
def video_get_track(self):
"""Get current video track.
@return: the video track (int)
"""
e=VLCException()
return libvlc_video_get_track(self, e)
if hasattr(dll, 'libvlc_video_set_track'):
def video_set_track(self, i_track):
"""Set video track.
@param i_track: the track (int)
"""
e=VLCException()
return libvlc_video_set_track(self, i_track, e)
if hasattr(dll, 'libvlc_video_take_snapshot'):
def video_take_snapshot(self, psz_filepath, i_width, i_height):
"""Take a snapshot of the current video window.
If i_width AND i_height is 0, original size is used.
If i_width XOR i_height is 0, original aspect-ratio is preserved.
@param psz_filepath: the path where to save the screenshot to
@param i_width: the snapshot's width
@param i_height: the snapshot's height
"""
e=VLCException()
return libvlc_video_take_snapshot(self, psz_filepath, i_width, i_height, e)
if hasattr(dll, 'libvlc_audio_get_track_count'):
def audio_get_track_count(self):
"""Get number of available audio tracks.
@return: the number of available audio tracks (int)
"""
e=VLCException()
return libvlc_audio_get_track_count(self, e)
if hasattr(dll, 'libvlc_audio_get_track_description'):
def audio_get_track_description(self):
"""Get the description of available audio tracks.
@return: list with description of available audio tracks
"""
e=VLCException()
return libvlc_audio_get_track_description(self, e)
if hasattr(dll, 'libvlc_audio_get_track'):
def audio_get_track(self):
"""Get current audio track.
@return: the audio track (int)
"""
e=VLCException()
return libvlc_audio_get_track(self, e)
if hasattr(dll, 'libvlc_audio_set_track'):
def audio_set_track(self, i_track):
"""Set current audio track.
@param i_track: the track (int)
"""
e=VLCException()
return libvlc_audio_set_track(self, i_track, e)
class TrackDescription(object):
def __new__(cls, pointer=None):
'''Internal method used for instanciating wrappers from ctypes.
'''
if pointer is None:
raise Exception("Internal method. Surely this class cannot be instanciated by itself.")
if pointer == 0:
return None
else:
o=object.__new__(cls)
o._as_parameter_=ctypes.c_void_p(pointer)
return o
@staticmethod
def from_param(arg):
'''(INTERNAL) ctypes parameter conversion method.
'''
return arg._as_parameter_
if hasattr(dll, 'libvlc_track_description_release'):
def release(self):
"""Release (free) libvlc_track_description_t
"""
return libvlc_track_description_release(self)
if hasattr(dll, 'libvlc_exception_init'):
prototype=ctypes.CFUNCTYPE(None, ctypes.POINTER(VLCException))
paramflags=( (3, ), )
libvlc_exception_init = prototype( ("libvlc_exception_init", dll), paramflags )
libvlc_exception_init.errcheck = check_vlc_exception
libvlc_exception_init.__doc__ = """Initialize an exception structure. This can be called several times to
reuse an exception structure.
@param p_exception the exception to initialize
"""
if hasattr(dll, 'libvlc_exception_clear'):
prototype=ctypes.CFUNCTYPE(None, ctypes.POINTER(VLCException))
paramflags=( (3, ), )
libvlc_exception_clear = prototype( ("libvlc_exception_clear", dll), paramflags )
libvlc_exception_clear.errcheck = check_vlc_exception
libvlc_exception_clear.__doc__ = """Clear an exception object so it can be reused.
The exception object must have be initialized.
@param p_exception the exception to clear
"""
if hasattr(dll, 'libvlc_new'):
prototype=ctypes.CFUNCTYPE(Instance, ctypes.c_int, ListPOINTER(ctypes.c_char_p), ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_new = prototype( ("libvlc_new", dll), paramflags )
libvlc_new.errcheck = check_vlc_exception
libvlc_new.__doc__ = """Create and initialize a libvlc instance.
@param argc the number of arguments
@param argv command-line-type arguments. argv[0] must be the path of the
calling program.
@param p_e an initialized exception pointer
@return the libvlc instance
"""
if hasattr(dll, 'libvlc_get_vlc_id'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance)
paramflags=( (1, ), )
libvlc_get_vlc_id = prototype( ("libvlc_get_vlc_id", dll), paramflags )
libvlc_get_vlc_id.__doc__ = """Return a libvlc instance identifier for legacy APIs. Use of this
function is discouraged, you should convert your program to use the
new API.
@param p_instance the instance
@return the instance identifier
"""
if hasattr(dll, 'libvlc_release'):
prototype=ctypes.CFUNCTYPE(None, Instance)
paramflags=( (1, ), )
libvlc_release = prototype( ("libvlc_release", dll), paramflags )
libvlc_release.__doc__ = """Decrement the reference count of a libvlc instance, and destroy it
if it reaches zero.
@param p_instance the instance to destroy
"""
if hasattr(dll, 'libvlc_retain'):
prototype=ctypes.CFUNCTYPE(None, Instance)
paramflags=( (1, ), )
libvlc_retain = prototype( ("libvlc_retain", dll), paramflags )
libvlc_retain.__doc__ = """Increments the reference count of a libvlc instance.
The initial reference count is 1 after libvlc_new() returns.
@param p_instance the instance to reference
"""
if hasattr(dll, 'libvlc_add_intf'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_add_intf = prototype( ("libvlc_add_intf", dll), paramflags )
libvlc_add_intf.errcheck = check_vlc_exception
libvlc_add_intf.__doc__ = """Try to start a user interface for the libvlc instance.
@param p_instance the instance
@param name interface name, or NULL for default
@param p_exception an initialized exception pointer
"""
if hasattr(dll, 'libvlc_wait'):
prototype=ctypes.CFUNCTYPE(None, Instance)
paramflags=( (1, ), )
libvlc_wait = prototype( ("libvlc_wait", dll), paramflags )
libvlc_wait.__doc__ = """Waits until an interface causes the instance to exit.
You should start at least one interface first, using libvlc_add_intf().
@param p_instance the instance
"""
if hasattr(dll, 'libvlc_get_version'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p)
paramflags= tuple()
libvlc_get_version = prototype( ("libvlc_get_version", dll), paramflags )
libvlc_get_version.__doc__ = """Retrieve libvlc version.
Example: "0.9.0-git Grishenko"
@return a string containing the libvlc version
"""
if hasattr(dll, 'libvlc_get_compiler'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p)
paramflags= tuple()
libvlc_get_compiler = prototype( ("libvlc_get_compiler", dll), paramflags )
libvlc_get_compiler.__doc__ = """Retrieve libvlc compiler version.
Example: "gcc version 4.2.3 (Ubuntu 4.2.3-2ubuntu6)"
@return a string containing the libvlc compiler version
"""
if hasattr(dll, 'libvlc_get_changeset'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p)
paramflags= tuple()
libvlc_get_changeset = prototype( ("libvlc_get_changeset", dll), paramflags )
libvlc_get_changeset.__doc__ = """Retrieve libvlc changeset.
Example: "aa9bce0bc4"
@return a string containing the libvlc changeset
"""
if hasattr(dll, 'libvlc_free'):
prototype=ctypes.CFUNCTYPE(None, ctypes.c_void_p)
paramflags=( (1, ), )
libvlc_free = prototype( ("libvlc_free", dll), paramflags )
libvlc_free.__doc__ = """Frees an heap allocation (char *) returned by a LibVLC API.
If you know you're using the same underlying C run-time as the LibVLC
implementation, then you can call ANSI C free() directly instead.
"""
if hasattr(dll, 'libvlc_event_attach'):
prototype=ctypes.CFUNCTYPE(None, EventManager, EventType, ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (1,), (3,)
libvlc_event_attach = prototype( ("libvlc_event_attach", dll), paramflags )
libvlc_event_attach.errcheck = check_vlc_exception
libvlc_event_attach.__doc__ = """Register for an event notification.
@param p_event_manager the event manager to which you want to attach to.
Generally it is obtained by vlc_my_object_event_manager() where
my_object is the object you want to listen to.
@param i_event_type the desired event to which we want to listen
@param f_callback the function to call when i_event_type occurs
@param user_data user provided data to carry with the event
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_event_detach'):
prototype=ctypes.CFUNCTYPE(None, EventManager, EventType, ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (1,), (3,)
libvlc_event_detach = prototype( ("libvlc_event_detach", dll), paramflags )
libvlc_event_detach.errcheck = check_vlc_exception
libvlc_event_detach.__doc__ = """Unregister an event notification.
@param p_event_manager the event manager
@param i_event_type the desired event to which we want to unregister
@param f_callback the function to call when i_event_type occurs
@param p_user_data user provided data to carry with the event
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_event_type_name'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p, EventType)
paramflags=( (1, ), )
libvlc_event_type_name = prototype( ("libvlc_event_type_name", dll), paramflags )
libvlc_event_type_name.__doc__ = """Get an event's type name.
@param i_event_type the desired event
"""
if hasattr(dll, 'libvlc_get_log_verbosity'):
prototype=ctypes.CFUNCTYPE(ctypes.c_uint, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_get_log_verbosity = prototype( ("libvlc_get_log_verbosity", dll), paramflags )
libvlc_get_log_verbosity.errcheck = check_vlc_exception
libvlc_get_log_verbosity.__doc__ = """Return the VLC messaging verbosity level.
@param p_instance libvlc instance
@param p_e an initialized exception pointer
@return verbosity level for messages
"""
if hasattr(dll, 'libvlc_set_log_verbosity'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_uint, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_set_log_verbosity = prototype( ("libvlc_set_log_verbosity", dll), paramflags )
libvlc_set_log_verbosity.errcheck = check_vlc_exception
libvlc_set_log_verbosity.__doc__ = """Set the VLC messaging verbosity level.
@param p_instance libvlc log instance
@param level log level
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_log_open'):
prototype=ctypes.CFUNCTYPE(Log, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_log_open = prototype( ("libvlc_log_open", dll), paramflags )
libvlc_log_open.errcheck = check_vlc_exception
libvlc_log_open.__doc__ = """Open a VLC message log instance.
@param p_instance libvlc instance
@param p_e an initialized exception pointer
@return log message instance
"""
if hasattr(dll, 'libvlc_log_close'):
prototype=ctypes.CFUNCTYPE(None, Log, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_log_close = prototype( ("libvlc_log_close", dll), paramflags )
libvlc_log_close.errcheck = check_vlc_exception
libvlc_log_close.__doc__ = """Close a VLC message log instance.
@param p_log libvlc log instance
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_log_count'):
prototype=ctypes.CFUNCTYPE(ctypes.c_uint, Log, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_log_count = prototype( ("libvlc_log_count", dll), paramflags )
libvlc_log_count.errcheck = check_vlc_exception
libvlc_log_count.__doc__ = """Returns the number of messages in a log instance.
@param p_log libvlc log instance
@param p_e an initialized exception pointer
@return number of log messages
"""
if hasattr(dll, 'libvlc_log_clear'):
prototype=ctypes.CFUNCTYPE(None, Log, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_log_clear = prototype( ("libvlc_log_clear", dll), paramflags )
libvlc_log_clear.errcheck = check_vlc_exception
libvlc_log_clear.__doc__ = """Clear a log instance.
All messages in the log are removed. The log should be cleared on a
regular basis to avoid clogging.
@param p_log libvlc log instance
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_log_get_iterator'):
prototype=ctypes.CFUNCTYPE(LogIterator, Log, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_log_get_iterator = prototype( ("libvlc_log_get_iterator", dll), paramflags )
libvlc_log_get_iterator.errcheck = check_vlc_exception
libvlc_log_get_iterator.__doc__ = """Allocate and returns a new iterator to messages in log.
@param p_log libvlc log instance
@param p_e an initialized exception pointer
@return log iterator object
"""
if hasattr(dll, 'libvlc_log_iterator_free'):
prototype=ctypes.CFUNCTYPE(None, LogIterator, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_log_iterator_free = prototype( ("libvlc_log_iterator_free", dll), paramflags )
libvlc_log_iterator_free.errcheck = check_vlc_exception
libvlc_log_iterator_free.__doc__ = """Release a previoulsy allocated iterator.
@param p_iter libvlc log iterator
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_log_iterator_has_next'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, LogIterator, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_log_iterator_has_next = prototype( ("libvlc_log_iterator_has_next", dll), paramflags )
libvlc_log_iterator_has_next.errcheck = check_vlc_exception
libvlc_log_iterator_has_next.__doc__ = """Return whether log iterator has more messages.
@param p_iter libvlc log iterator
@param p_e an initialized exception pointer
@return true if iterator has more message objects, else false
"""
if hasattr(dll, 'libvlc_log_iterator_next'):
prototype=ctypes.CFUNCTYPE(ctypes.POINTER(LogMessage), LogIterator, ctypes.POINTER(LogMessage), ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_log_iterator_next = prototype( ("libvlc_log_iterator_next", dll), paramflags )
libvlc_log_iterator_next.errcheck = check_vlc_exception
libvlc_log_iterator_next.__doc__ = """Return the next log message.
The message contents must not be freed
@param p_iter libvlc log iterator
@param p_buffer log buffer
@param p_e an initialized exception pointer
@return log message object
"""
if hasattr(dll, 'libvlc_media_new'):
prototype=ctypes.CFUNCTYPE(Media, Instance, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_new = prototype( ("libvlc_media_new", dll), paramflags )
libvlc_media_new.errcheck = check_vlc_exception
libvlc_media_new.__doc__ = """Create a media with the given MRL.
@param p_instance the instance
@param psz_mrl the MRL to read
@param p_e an initialized exception pointer
@return the newly created media
"""
if hasattr(dll, 'libvlc_media_new_as_node'):
prototype=ctypes.CFUNCTYPE(Media, Instance, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_new_as_node = prototype( ("libvlc_media_new_as_node", dll), paramflags )
libvlc_media_new_as_node.errcheck = check_vlc_exception
libvlc_media_new_as_node.__doc__ = """Create a media as an empty node with the passed name.
@param p_instance the instance
@param psz_name the name of the node
@param p_e an initialized exception pointer
@return the new empty media
"""
if hasattr(dll, 'libvlc_media_add_option'):
prototype=ctypes.CFUNCTYPE(None, Media, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_add_option = prototype( ("libvlc_media_add_option", dll), paramflags )
libvlc_media_add_option.errcheck = check_vlc_exception
libvlc_media_add_option.__doc__ = """Add an option to the media.
This option will be used to determine how the media_player will
read the media. This allows to use VLC's advanced
reading/streaming options on a per-media basis.
The options are detailed in vlc --long-help, for instance "--sout-all"
@param p_instance the instance
@param ppsz_options the options (as a string)
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_add_option_untrusted'):
prototype=ctypes.CFUNCTYPE(None, Media, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_add_option_untrusted = prototype( ("libvlc_media_add_option_untrusted", dll), paramflags )
libvlc_media_add_option_untrusted.errcheck = check_vlc_exception
libvlc_media_add_option_untrusted.__doc__ = """Add an option to the media from an untrusted source.
This option will be used to determine how the media_player will
read the media. This allows to use VLC's advanced
reading/streaming options on a per-media basis.
The options are detailed in vlc --long-help, for instance "--sout-all"
@param p_instance the instance
@param ppsz_options the options (as a string)
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_retain'):
prototype=ctypes.CFUNCTYPE(None, Media)
paramflags=( (1, ), )
libvlc_media_retain = prototype( ("libvlc_media_retain", dll), paramflags )
libvlc_media_retain.__doc__ = """Retain a reference to a media descriptor object (libvlc_media_t). Use
libvlc_media_release() to decrement the reference count of a
media descriptor object.
@param p_meta_desc a media descriptor object.
"""
if hasattr(dll, 'libvlc_media_release'):
prototype=ctypes.CFUNCTYPE(None, Media)
paramflags=( (1, ), )
libvlc_media_release = prototype( ("libvlc_media_release", dll), paramflags )
libvlc_media_release.__doc__ = """Decrement the reference count of a media descriptor object. If the
reference count is 0, then libvlc_media_release() will release the
media descriptor object. It will send out an libvlc_MediaFreed event
to all listeners. If the media descriptor object has been released it
should not be used again.
@param p_meta_desc a media descriptor object.
"""
if hasattr(dll, 'libvlc_media_get_mrl'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_get_mrl = prototype( ("libvlc_media_get_mrl", dll), paramflags )
libvlc_media_get_mrl.errcheck = check_vlc_exception
libvlc_media_get_mrl.__doc__ = """Get the media resource locator (mrl) from a media descriptor object
@param p_md a media descriptor object
@param p_e an initialized exception object
@return string with mrl of media descriptor object
"""
if hasattr(dll, 'libvlc_media_duplicate'):
prototype=ctypes.CFUNCTYPE(Media, Media)
paramflags=( (1, ), )
libvlc_media_duplicate = prototype( ("libvlc_media_duplicate", dll), paramflags )
libvlc_media_duplicate.__doc__ = """Duplicate a media descriptor object.
@param p_meta_desc a media descriptor object.
"""
if hasattr(dll, 'libvlc_media_get_meta'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p, Media, Meta, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_get_meta = prototype( ("libvlc_media_get_meta", dll), paramflags )
libvlc_media_get_meta.errcheck = check_vlc_exception
libvlc_media_get_meta.__doc__ = """Read the meta of the media.
@param p_meta_desc the media to read
@param e_meta the meta to read
@param p_e an initialized exception pointer
@return the media's meta
"""
if hasattr(dll, 'libvlc_media_get_state'):
prototype=ctypes.CFUNCTYPE(State, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_get_state = prototype( ("libvlc_media_get_state", dll), paramflags )
libvlc_media_get_state.errcheck = check_vlc_exception
libvlc_media_get_state.__doc__ = """Get current state of media descriptor object. Possible media states
are defined in libvlc_structures.c ( libvlc_NothingSpecial=0,
libvlc_Opening, libvlc_Buffering, libvlc_Playing, libvlc_Paused,
libvlc_Stopped, libvlc_Ended,
libvlc_Error).
@see libvlc_state_t
@param p_meta_desc a media descriptor object
@param p_e an initialized exception object
@return state of media descriptor object
"""
if hasattr(dll, 'libvlc_media_subitems'):
prototype=ctypes.CFUNCTYPE(MediaList, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_subitems = prototype( ("libvlc_media_subitems", dll), paramflags )
libvlc_media_subitems.errcheck = check_vlc_exception
libvlc_media_subitems.__doc__ = """Get subitems of media descriptor object. This will increment
the reference count of supplied media descriptor object. Use
libvlc_media_list_release() to decrement the reference counting.
@param p_md media descriptor object
@param p_e initalized exception object
@return list of media descriptor subitems or NULL
and this is here for convenience */
"""
if hasattr(dll, 'libvlc_media_event_manager'):
prototype=ctypes.CFUNCTYPE(EventManager, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_event_manager = prototype( ("libvlc_media_event_manager", dll), paramflags )
libvlc_media_event_manager.errcheck = check_vlc_exception
libvlc_media_event_manager.__doc__ = """Get event manager from media descriptor object.
NOTE: this function doesn't increment reference counting.
@param p_md a media descriptor object
@param p_e an initialized exception object
@return event manager object
"""
if hasattr(dll, 'libvlc_media_get_duration'):
prototype=ctypes.CFUNCTYPE(ctypes.c_longlong, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_get_duration = prototype( ("libvlc_media_get_duration", dll), paramflags )
libvlc_media_get_duration.errcheck = check_vlc_exception
libvlc_media_get_duration.__doc__ = """Get duration of media descriptor object item.
@param p_md media descriptor object
@param p_e an initialized exception object
@return duration of media item
"""
if hasattr(dll, 'libvlc_media_is_preparsed'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_is_preparsed = prototype( ("libvlc_media_is_preparsed", dll), paramflags )
libvlc_media_is_preparsed.errcheck = check_vlc_exception
libvlc_media_is_preparsed.__doc__ = """Get preparsed status for media descriptor object.
@param p_md media descriptor object
@param p_e an initialized exception object
@return true if media object has been preparsed otherwise it returns false
"""
if hasattr(dll, 'libvlc_media_set_user_data'):
prototype=ctypes.CFUNCTYPE(None, Media, ctypes.c_void_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_set_user_data = prototype( ("libvlc_media_set_user_data", dll), paramflags )
libvlc_media_set_user_data.errcheck = check_vlc_exception
libvlc_media_set_user_data.__doc__ = """Sets media descriptor's user_data. user_data is specialized data
accessed by the host application, VLC.framework uses it as a pointer to
an native object that references a libvlc_media_t pointer
@param p_md media descriptor object
@param p_new_user_data pointer to user data
@param p_e an initialized exception object
"""
if hasattr(dll, 'libvlc_media_get_user_data'):
prototype=ctypes.CFUNCTYPE(ctypes.c_void_p, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_get_user_data = prototype( ("libvlc_media_get_user_data", dll), paramflags )
libvlc_media_get_user_data.errcheck = check_vlc_exception
libvlc_media_get_user_data.__doc__ = """Get media descriptor's user_data. user_data is specialized data
accessed by the host application, VLC.framework uses it as a pointer to
an native object that references a libvlc_media_t pointer
@param p_md media descriptor object
@param p_e an initialized exception object
"""
if hasattr(dll, 'libvlc_media_discoverer_new_from_name'):
prototype=ctypes.CFUNCTYPE(MediaDiscoverer, Instance, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_discoverer_new_from_name = prototype( ("libvlc_media_discoverer_new_from_name", dll), paramflags )
libvlc_media_discoverer_new_from_name.errcheck = check_vlc_exception
libvlc_media_discoverer_new_from_name.__doc__ = """Discover media service by name.
@param p_inst libvlc instance
@param psz_name service name
@param p_e an initialized exception object
@return media discover object
"""
if hasattr(dll, 'libvlc_media_discoverer_release'):
prototype=ctypes.CFUNCTYPE(None, MediaDiscoverer)
paramflags=( (1, ), )
libvlc_media_discoverer_release = prototype( ("libvlc_media_discoverer_release", dll), paramflags )
libvlc_media_discoverer_release.__doc__ = """Release media discover object. If the reference count reaches 0, then
the object will be released.
@param p_mdis media service discover object
"""
if hasattr(dll, 'libvlc_media_discoverer_localized_name'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p, MediaDiscoverer)
paramflags=( (1, ), )
libvlc_media_discoverer_localized_name = prototype( ("libvlc_media_discoverer_localized_name", dll), paramflags )
libvlc_media_discoverer_localized_name.__doc__ = """Get media service discover object its localized name.
@param media discover object
@return localized name
"""
if hasattr(dll, 'libvlc_media_discoverer_media_list'):
prototype=ctypes.CFUNCTYPE(MediaList, MediaDiscoverer)
paramflags=( (1, ), )
libvlc_media_discoverer_media_list = prototype( ("libvlc_media_discoverer_media_list", dll), paramflags )
libvlc_media_discoverer_media_list.__doc__ = """Get media service discover media list.
@param p_mdis media service discover object
@return list of media items
"""
if hasattr(dll, 'libvlc_media_discoverer_event_manager'):
prototype=ctypes.CFUNCTYPE(EventManager, MediaDiscoverer)
paramflags=( (1, ), )
libvlc_media_discoverer_event_manager = prototype( ("libvlc_media_discoverer_event_manager", dll), paramflags )
libvlc_media_discoverer_event_manager.__doc__ = """Get event manager from media service discover object.
@param p_mdis media service discover object
@return event manager object.
"""
if hasattr(dll, 'libvlc_media_discoverer_is_running'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaDiscoverer)
paramflags=( (1, ), )
libvlc_media_discoverer_is_running = prototype( ("libvlc_media_discoverer_is_running", dll), paramflags )
libvlc_media_discoverer_is_running.__doc__ = """Query if media service discover object is running.
@param p_mdis media service discover object
@return true if running, false if not
"""
if hasattr(dll, 'libvlc_media_library_new'):
prototype=ctypes.CFUNCTYPE(MediaLibrary, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_library_new = prototype( ("libvlc_media_library_new", dll), paramflags )
libvlc_media_library_new.errcheck = check_vlc_exception
libvlc_media_library_new.__doc__ = """\ingroup libvlc
LibVLC Media Library
@{
"""
if hasattr(dll, 'libvlc_media_library_release'):
prototype=ctypes.CFUNCTYPE(None, MediaLibrary)
paramflags=( (1, ), )
libvlc_media_library_release = prototype( ("libvlc_media_library_release", dll), paramflags )
libvlc_media_library_release.__doc__ = """Release media library object. This functions decrements the
reference count of the media library object. If it reaches 0,
then the object will be released.
@param p_mlib media library object
"""
if hasattr(dll, 'libvlc_media_library_retain'):
prototype=ctypes.CFUNCTYPE(None, MediaLibrary)
paramflags=( (1, ), )
libvlc_media_library_retain = prototype( ("libvlc_media_library_retain", dll), paramflags )
libvlc_media_library_retain.__doc__ = """Retain a reference to a media library object. This function will
increment the reference counting for this object. Use
libvlc_media_library_release() to decrement the reference count.
@param p_mlib media library object
"""
if hasattr(dll, 'libvlc_media_library_load'):
prototype=ctypes.CFUNCTYPE(None, MediaLibrary, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_library_load = prototype( ("libvlc_media_library_load", dll), paramflags )
libvlc_media_library_load.errcheck = check_vlc_exception
libvlc_media_library_load.__doc__ = """Load media library.
@param p_mlib media library object
@param p_e an initialized exception object.
"""
if hasattr(dll, 'libvlc_media_library_save'):
prototype=ctypes.CFUNCTYPE(None, MediaLibrary, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_library_save = prototype( ("libvlc_media_library_save", dll), paramflags )
libvlc_media_library_save.errcheck = check_vlc_exception
libvlc_media_library_save.__doc__ = """Save media library.
@param p_mlib media library object
@param p_e an initialized exception object.
"""
if hasattr(dll, 'libvlc_media_library_media_list'):
prototype=ctypes.CFUNCTYPE(MediaList, MediaLibrary, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_library_media_list = prototype( ("libvlc_media_library_media_list", dll), paramflags )
libvlc_media_library_media_list.errcheck = check_vlc_exception
libvlc_media_library_media_list.__doc__ = """Get media library subitems.
@param p_mlib media library object
@param p_e an initialized exception object.
@return media list subitems
"""
if hasattr(dll, 'libvlc_media_list_new'):
prototype=ctypes.CFUNCTYPE(MediaList, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_new = prototype( ("libvlc_media_list_new", dll), paramflags )
libvlc_media_list_new.errcheck = check_vlc_exception
libvlc_media_list_new.__doc__ = """Create an empty media list.
@param p_libvlc libvlc instance
@param p_e an initialized exception pointer
@return empty media list
"""
if hasattr(dll, 'libvlc_media_list_release'):
prototype=ctypes.CFUNCTYPE(None, MediaList)
paramflags=( (1, ), )
libvlc_media_list_release = prototype( ("libvlc_media_list_release", dll), paramflags )
libvlc_media_list_release.__doc__ = """Release media list created with libvlc_media_list_new().
@param p_ml a media list created with libvlc_media_list_new()
"""
if hasattr(dll, 'libvlc_media_list_retain'):
prototype=ctypes.CFUNCTYPE(None, MediaList)
paramflags=( (1, ), )
libvlc_media_list_retain = prototype( ("libvlc_media_list_retain", dll), paramflags )
libvlc_media_list_retain.__doc__ = """Retain reference to a media list
@param p_ml a media list created with libvlc_media_list_new()
"""
if hasattr(dll, 'libvlc_media_list_set_media'):
prototype=ctypes.CFUNCTYPE(None, MediaList, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_set_media = prototype( ("libvlc_media_list_set_media", dll), paramflags )
libvlc_media_list_set_media.errcheck = check_vlc_exception
libvlc_media_list_set_media.__doc__ = """Associate media instance with this media list instance.
If another media instance was present it will be released.
The libvlc_media_list_lock should NOT be held upon entering this function.
@param p_ml a media list instance
@param p_mi media instance to add
@param p_e initialized exception object
"""
if hasattr(dll, 'libvlc_media_list_media'):
prototype=ctypes.CFUNCTYPE(Media, MediaList, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_media = prototype( ("libvlc_media_list_media", dll), paramflags )
libvlc_media_list_media.errcheck = check_vlc_exception
libvlc_media_list_media.__doc__ = """Get media instance from this media list instance. This action will increase
the refcount on the media instance.
The libvlc_media_list_lock should NOT be held upon entering this function.
@param p_ml a media list instance
@param p_e initialized exception object
@return media instance
"""
if hasattr(dll, 'libvlc_media_list_add_media'):
prototype=ctypes.CFUNCTYPE(None, MediaList, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_add_media = prototype( ("libvlc_media_list_add_media", dll), paramflags )
libvlc_media_list_add_media.errcheck = check_vlc_exception
libvlc_media_list_add_media.__doc__ = """Add media instance to media list
The libvlc_media_list_lock should be held upon entering this function.
@param p_ml a media list instance
@param p_mi a media instance
@param p_e initialized exception object
"""
if hasattr(dll, 'libvlc_media_list_insert_media'):
prototype=ctypes.CFUNCTYPE(None, MediaList, Media, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_media_list_insert_media = prototype( ("libvlc_media_list_insert_media", dll), paramflags )
libvlc_media_list_insert_media.errcheck = check_vlc_exception
libvlc_media_list_insert_media.__doc__ = """Insert media instance in media list on a position
The libvlc_media_list_lock should be held upon entering this function.
@param p_ml a media list instance
@param p_mi a media instance
@param i_pos position in array where to insert
@param p_e initialized exception object
"""
if hasattr(dll, 'libvlc_media_list_remove_index'):
prototype=ctypes.CFUNCTYPE(None, MediaList, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_remove_index = prototype( ("libvlc_media_list_remove_index", dll), paramflags )
libvlc_media_list_remove_index.errcheck = check_vlc_exception
libvlc_media_list_remove_index.__doc__ = """Remove media instance from media list on a position
The libvlc_media_list_lock should be held upon entering this function.
@param p_ml a media list instance
@param i_pos position in array where to insert
@param p_e initialized exception object
"""
if hasattr(dll, 'libvlc_media_list_count'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaList, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_count = prototype( ("libvlc_media_list_count", dll), paramflags )
libvlc_media_list_count.errcheck = check_vlc_exception
libvlc_media_list_count.__doc__ = """Get count on media list items
The libvlc_media_list_lock should be held upon entering this function.
@param p_ml a media list instance
@param p_e initialized exception object
@return number of items in media list
"""
if hasattr(dll, 'libvlc_media_list_item_at_index'):
prototype=ctypes.CFUNCTYPE(Media, MediaList, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_item_at_index = prototype( ("libvlc_media_list_item_at_index", dll), paramflags )
libvlc_media_list_item_at_index.errcheck = check_vlc_exception
libvlc_media_list_item_at_index.__doc__ = """List media instance in media list at a position
The libvlc_media_list_lock should be held upon entering this function.
@param p_ml a media list instance
@param i_pos position in array where to insert
@param p_e initialized exception object
@return media instance at position i_pos and libvlc_media_retain() has been called to increase the refcount on this object.
"""
if hasattr(dll, 'libvlc_media_list_index_of_item'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaList, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_index_of_item = prototype( ("libvlc_media_list_index_of_item", dll), paramflags )
libvlc_media_list_index_of_item.errcheck = check_vlc_exception
libvlc_media_list_index_of_item.__doc__ = """Find index position of List media instance in media list.
Warning: the function will return the first matched position.
The libvlc_media_list_lock should be held upon entering this function.
@param p_ml a media list instance
@param p_mi media list instance
@param p_e initialized exception object
@return position of media instance
"""
if hasattr(dll, 'libvlc_media_list_is_readonly'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaList)
paramflags=( (1, ), )
libvlc_media_list_is_readonly = prototype( ("libvlc_media_list_is_readonly", dll), paramflags )
libvlc_media_list_is_readonly.__doc__ = """This indicates if this media list is read-only from a user point of view
@param p_ml media list instance
@return 0 on readonly, 1 on readwrite
"""
if hasattr(dll, 'libvlc_media_list_lock'):
prototype=ctypes.CFUNCTYPE(None, MediaList)
paramflags=( (1, ), )
libvlc_media_list_lock = prototype( ("libvlc_media_list_lock", dll), paramflags )
libvlc_media_list_lock.__doc__ = """Get lock on media list items
@param p_ml a media list instance
"""
if hasattr(dll, 'libvlc_media_list_unlock'):
prototype=ctypes.CFUNCTYPE(None, MediaList)
paramflags=( (1, ), )
libvlc_media_list_unlock = prototype( ("libvlc_media_list_unlock", dll), paramflags )
libvlc_media_list_unlock.__doc__ = """Release lock on media list items
The libvlc_media_list_lock should be held upon entering this function.
@param p_ml a media list instance
"""
if hasattr(dll, 'libvlc_media_list_flat_view'):
prototype=ctypes.CFUNCTYPE(MediaListView, MediaList, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_flat_view = prototype( ("libvlc_media_list_flat_view", dll), paramflags )
libvlc_media_list_flat_view.errcheck = check_vlc_exception
libvlc_media_list_flat_view.__doc__ = """Get a flat media list view of media list items
@param p_ml a media list instance
@param p_ex an excpetion instance
@return flat media list view instance
"""
if hasattr(dll, 'libvlc_media_list_hierarchical_view'):
prototype=ctypes.CFUNCTYPE(MediaListView, MediaList, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_hierarchical_view = prototype( ("libvlc_media_list_hierarchical_view", dll), paramflags )
libvlc_media_list_hierarchical_view.errcheck = check_vlc_exception
libvlc_media_list_hierarchical_view.__doc__ = """Get a hierarchical media list view of media list items
@param p_ml a media list instance
@param p_ex an excpetion instance
@return hierarchical media list view instance
"""
if hasattr(dll, 'libvlc_media_list_hierarchical_node_view'):
prototype=ctypes.CFUNCTYPE(MediaListView, MediaList, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_hierarchical_node_view = prototype( ("libvlc_media_list_hierarchical_node_view", dll), paramflags )
libvlc_media_list_hierarchical_node_view.errcheck = check_vlc_exception
libvlc_media_list_hierarchical_node_view.__doc__ = """"""
if hasattr(dll, 'libvlc_media_list_event_manager'):
prototype=ctypes.CFUNCTYPE(EventManager, MediaList, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_event_manager = prototype( ("libvlc_media_list_event_manager", dll), paramflags )
libvlc_media_list_event_manager.errcheck = check_vlc_exception
libvlc_media_list_event_manager.__doc__ = """Get libvlc_event_manager from this media list instance.
The p_event_manager is immutable, so you don't have to hold the lock
@param p_ml a media list instance
@param p_ex an excpetion instance
@return libvlc_event_manager
"""
if hasattr(dll, 'libvlc_media_list_player_new'):
prototype=ctypes.CFUNCTYPE(MediaListPlayer, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_player_new = prototype( ("libvlc_media_list_player_new", dll), paramflags )
libvlc_media_list_player_new.errcheck = check_vlc_exception
libvlc_media_list_player_new.__doc__ = """Create new media_list_player.
@param p_instance libvlc instance
@param p_e initialized exception instance
@return media list player instance
"""
if hasattr(dll, 'libvlc_media_list_player_release'):
prototype=ctypes.CFUNCTYPE(None, MediaListPlayer)
paramflags=( (1, ), )
libvlc_media_list_player_release = prototype( ("libvlc_media_list_player_release", dll), paramflags )
libvlc_media_list_player_release.__doc__ = """Release media_list_player.
@param p_mlp media list player instance
"""
if hasattr(dll, 'libvlc_media_list_player_set_media_player'):
prototype=ctypes.CFUNCTYPE(None, MediaListPlayer, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_player_set_media_player = prototype( ("libvlc_media_list_player_set_media_player", dll), paramflags )
libvlc_media_list_player_set_media_player.errcheck = check_vlc_exception
libvlc_media_list_player_set_media_player.__doc__ = """Replace media player in media_list_player with this instance.
@param p_mlp media list player instance
@param p_mi media player instance
@param p_e initialized exception instance
"""
if hasattr(dll, 'libvlc_media_list_player_set_media_list'):
prototype=ctypes.CFUNCTYPE(None, MediaListPlayer, MediaList, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_player_set_media_list = prototype( ("libvlc_media_list_player_set_media_list", dll), paramflags )
libvlc_media_list_player_set_media_list.errcheck = check_vlc_exception
libvlc_media_list_player_set_media_list.__doc__ = """"""
if hasattr(dll, 'libvlc_media_list_player_play'):
prototype=ctypes.CFUNCTYPE(None, MediaListPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_player_play = prototype( ("libvlc_media_list_player_play", dll), paramflags )
libvlc_media_list_player_play.errcheck = check_vlc_exception
libvlc_media_list_player_play.__doc__ = """Play media list
@param p_mlp media list player instance
@param p_e initialized exception instance
"""
if hasattr(dll, 'libvlc_media_list_player_pause'):
prototype=ctypes.CFUNCTYPE(None, MediaListPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_player_pause = prototype( ("libvlc_media_list_player_pause", dll), paramflags )
libvlc_media_list_player_pause.errcheck = check_vlc_exception
libvlc_media_list_player_pause.__doc__ = """Pause media list
@param p_mlp media list player instance
@param p_e initialized exception instance
"""
if hasattr(dll, 'libvlc_media_list_player_is_playing'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaListPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_player_is_playing = prototype( ("libvlc_media_list_player_is_playing", dll), paramflags )
libvlc_media_list_player_is_playing.errcheck = check_vlc_exception
libvlc_media_list_player_is_playing.__doc__ = """Is media list playing?
@param p_mlp media list player instance
@param p_e initialized exception instance
@return true for playing and false for not playing
"""
if hasattr(dll, 'libvlc_media_list_player_get_state'):
prototype=ctypes.CFUNCTYPE(State, MediaListPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_player_get_state = prototype( ("libvlc_media_list_player_get_state", dll), paramflags )
libvlc_media_list_player_get_state.errcheck = check_vlc_exception
libvlc_media_list_player_get_state.__doc__ = """Get current libvlc_state of media list player
@param p_mlp media list player instance
@param p_e initialized exception instance
@return libvlc_state_t for media list player
"""
if hasattr(dll, 'libvlc_media_list_player_play_item_at_index'):
prototype=ctypes.CFUNCTYPE(None, MediaListPlayer, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_player_play_item_at_index = prototype( ("libvlc_media_list_player_play_item_at_index", dll), paramflags )
libvlc_media_list_player_play_item_at_index.errcheck = check_vlc_exception
libvlc_media_list_player_play_item_at_index.__doc__ = """Play media list item at position index
@param p_mlp media list player instance
@param i_index index in media list to play
@param p_e initialized exception instance
"""
if hasattr(dll, 'libvlc_media_list_player_play_item'):
prototype=ctypes.CFUNCTYPE(None, MediaListPlayer, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_player_play_item = prototype( ("libvlc_media_list_player_play_item", dll), paramflags )
libvlc_media_list_player_play_item.errcheck = check_vlc_exception
libvlc_media_list_player_play_item.__doc__ = """"""
if hasattr(dll, 'libvlc_media_list_player_stop'):
prototype=ctypes.CFUNCTYPE(None, MediaListPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_player_stop = prototype( ("libvlc_media_list_player_stop", dll), paramflags )
libvlc_media_list_player_stop.errcheck = check_vlc_exception
libvlc_media_list_player_stop.__doc__ = """Stop playing media list
@param p_mlp media list player instance
@param p_e initialized exception instance
"""
if hasattr(dll, 'libvlc_media_list_player_next'):
prototype=ctypes.CFUNCTYPE(None, MediaListPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_player_next = prototype( ("libvlc_media_list_player_next", dll), paramflags )
libvlc_media_list_player_next.errcheck = check_vlc_exception
libvlc_media_list_player_next.__doc__ = """Play next item from media list
@param p_mlp media list player instance
@param p_e initialized exception instance
"""
if hasattr(dll, 'libvlc_media_list_view_retain'):
prototype=ctypes.CFUNCTYPE(None, MediaListView)
paramflags=( (1, ), )
libvlc_media_list_view_retain = prototype( ("libvlc_media_list_view_retain", dll), paramflags )
libvlc_media_list_view_retain.__doc__ = """Retain reference to a media list view
@param p_mlv a media list view created with libvlc_media_list_view_new()
"""
if hasattr(dll, 'libvlc_media_list_view_release'):
prototype=ctypes.CFUNCTYPE(None, MediaListView)
paramflags=( (1, ), )
libvlc_media_list_view_release = prototype( ("libvlc_media_list_view_release", dll), paramflags )
libvlc_media_list_view_release.__doc__ = """Release reference to a media list view. If the refcount reaches 0, then
the object will be released.
@param p_mlv a media list view created with libvlc_media_list_view_new()
"""
if hasattr(dll, 'libvlc_media_list_view_event_manager'):
prototype=ctypes.CFUNCTYPE(EventManager, MediaListView)
paramflags=( (1, ), )
libvlc_media_list_view_event_manager = prototype( ("libvlc_media_list_view_event_manager", dll), paramflags )
libvlc_media_list_view_event_manager.__doc__ = """Get libvlc_event_manager from this media list view instance.
The p_event_manager is immutable, so you don't have to hold the lock
@param p_mlv a media list view instance
@return libvlc_event_manager
"""
if hasattr(dll, 'libvlc_media_list_view_count'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaListView, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_view_count = prototype( ("libvlc_media_list_view_count", dll), paramflags )
libvlc_media_list_view_count.errcheck = check_vlc_exception
libvlc_media_list_view_count.__doc__ = """Get count on media list view items
@param p_mlv a media list view instance
@param p_e initialized exception object
@return number of items in media list view
"""
if hasattr(dll, 'libvlc_media_list_view_item_at_index'):
prototype=ctypes.CFUNCTYPE(Media, MediaListView, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_view_item_at_index = prototype( ("libvlc_media_list_view_item_at_index", dll), paramflags )
libvlc_media_list_view_item_at_index.errcheck = check_vlc_exception
libvlc_media_list_view_item_at_index.__doc__ = """List media instance in media list view at an index position
@param p_mlv a media list view instance
@param i_index index position in array where to insert
@param p_e initialized exception object
@return media instance at position i_pos and libvlc_media_retain() has been called to increase the refcount on this object.
"""
if hasattr(dll, 'libvlc_media_list_view_children_at_index'):
prototype=ctypes.CFUNCTYPE(MediaListView, MediaListView, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_view_children_at_index = prototype( ("libvlc_media_list_view_children_at_index", dll), paramflags )
libvlc_media_list_view_children_at_index.errcheck = check_vlc_exception
libvlc_media_list_view_children_at_index.__doc__ = """"""
if hasattr(dll, 'libvlc_media_list_view_children_for_item'):
prototype=ctypes.CFUNCTYPE(MediaListView, MediaListView, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_list_view_children_for_item = prototype( ("libvlc_media_list_view_children_for_item", dll), paramflags )
libvlc_media_list_view_children_for_item.errcheck = check_vlc_exception
libvlc_media_list_view_children_for_item.__doc__ = """"""
if hasattr(dll, 'libvlc_media_list_view_parent_media_list'):
prototype=ctypes.CFUNCTYPE(MediaList, MediaListView, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_list_view_parent_media_list = prototype( ("libvlc_media_list_view_parent_media_list", dll), paramflags )
libvlc_media_list_view_parent_media_list.errcheck = check_vlc_exception
libvlc_media_list_view_parent_media_list.__doc__ = """"""
if hasattr(dll, 'libvlc_media_player_new'):
prototype=ctypes.CFUNCTYPE(MediaPlayer, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_new = prototype( ("libvlc_media_player_new", dll), paramflags )
libvlc_media_player_new.errcheck = check_vlc_exception
libvlc_media_player_new.__doc__ = """Create an empty Media Player object
@param p_libvlc_instance the libvlc instance in which the Media Player
should be created.
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_new_from_media'):
prototype=ctypes.CFUNCTYPE(MediaPlayer, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_new_from_media = prototype( ("libvlc_media_player_new_from_media", dll), paramflags )
libvlc_media_player_new_from_media.errcheck = check_vlc_exception
libvlc_media_player_new_from_media.__doc__ = """Create a Media Player object from a Media
@param p_md the media. Afterwards the p_md can be safely
destroyed.
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_release'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer)
paramflags=( (1, ), )
libvlc_media_player_release = prototype( ("libvlc_media_player_release", dll), paramflags )
libvlc_media_player_release.__doc__ = """Release a media_player after use
Decrement the reference count of a media player object. If the
reference count is 0, then libvlc_media_player_release() will
release the media player object. If the media player object
has been released, then it should not be used again.
@param p_mi the Media Player to free
"""
if hasattr(dll, 'libvlc_media_player_retain'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer)
paramflags=( (1, ), )
libvlc_media_player_retain = prototype( ("libvlc_media_player_retain", dll), paramflags )
libvlc_media_player_retain.__doc__ = """Retain a reference to a media player object. Use
libvlc_media_player_release() to decrement reference count.
@param p_mi media player object
"""
if hasattr(dll, 'libvlc_media_player_set_media'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, Media, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_player_set_media = prototype( ("libvlc_media_player_set_media", dll), paramflags )
libvlc_media_player_set_media.errcheck = check_vlc_exception
libvlc_media_player_set_media.__doc__ = """Set the media that will be used by the media_player. If any,
previous md will be released.
@param p_mi the Media Player
@param p_md the Media. Afterwards the p_md can be safely
destroyed.
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_get_media'):
prototype=ctypes.CFUNCTYPE(Media, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_get_media = prototype( ("libvlc_media_player_get_media", dll), paramflags )
libvlc_media_player_get_media.errcheck = check_vlc_exception
libvlc_media_player_get_media.__doc__ = """Get the media used by the media_player.
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return the media associated with p_mi, or NULL if no
media is associated
"""
if hasattr(dll, 'libvlc_media_player_event_manager'):
prototype=ctypes.CFUNCTYPE(EventManager, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_event_manager = prototype( ("libvlc_media_player_event_manager", dll), paramflags )
libvlc_media_player_event_manager.errcheck = check_vlc_exception
libvlc_media_player_event_manager.__doc__ = """Get the Event Manager from which the media player send event.
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return the event manager associated with p_mi
"""
if hasattr(dll, 'libvlc_media_player_is_playing'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_is_playing = prototype( ("libvlc_media_player_is_playing", dll), paramflags )
libvlc_media_player_is_playing.errcheck = check_vlc_exception
libvlc_media_player_is_playing.__doc__ = """is_playing
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return 1 if the media player is playing, 0 otherwise
"""
if hasattr(dll, 'libvlc_media_player_play'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_play = prototype( ("libvlc_media_player_play", dll), paramflags )
libvlc_media_player_play.errcheck = check_vlc_exception
libvlc_media_player_play.__doc__ = """Play
@param p_mi the Media Player
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_pause'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_pause = prototype( ("libvlc_media_player_pause", dll), paramflags )
libvlc_media_player_pause.errcheck = check_vlc_exception
libvlc_media_player_pause.__doc__ = """Pause
@param p_mi the Media Player
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_stop'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_stop = prototype( ("libvlc_media_player_stop", dll), paramflags )
libvlc_media_player_stop.errcheck = check_vlc_exception
libvlc_media_player_stop.__doc__ = """Stop
@param p_mi the Media Player
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_set_nsobject'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_void_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_player_set_nsobject = prototype( ("libvlc_media_player_set_nsobject", dll), paramflags )
libvlc_media_player_set_nsobject.errcheck = check_vlc_exception
libvlc_media_player_set_nsobject.__doc__ = """Set the agl handler where the media player should render its video output.
@param p_mi the Media Player
@param drawable the agl handler
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_get_nsobject'):
prototype=ctypes.CFUNCTYPE(ctypes.c_void_p, MediaPlayer)
paramflags=( (1, ), )
libvlc_media_player_get_nsobject = prototype( ("libvlc_media_player_get_nsobject", dll), paramflags )
libvlc_media_player_get_nsobject.__doc__ = """Get the agl handler previously set with libvlc_media_player_set_agl().
@return the agl handler or 0 if none where set
"""
if hasattr(dll, 'libvlc_media_player_set_agl'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_uint, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_player_set_agl = prototype( ("libvlc_media_player_set_agl", dll), paramflags )
libvlc_media_player_set_agl.errcheck = check_vlc_exception
libvlc_media_player_set_agl.__doc__ = """Set the agl handler where the media player should render its video output.
@param p_mi the Media Player
@param drawable the agl handler
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_get_agl'):
prototype=ctypes.CFUNCTYPE(ctypes.c_uint, MediaPlayer)
paramflags=( (1, ), )
libvlc_media_player_get_agl = prototype( ("libvlc_media_player_get_agl", dll), paramflags )
libvlc_media_player_get_agl.__doc__ = """Get the agl handler previously set with libvlc_media_player_set_agl().
@param p_mi the Media Player
@return the agl handler or 0 if none where set
"""
if hasattr(dll, 'libvlc_media_player_set_xwindow'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_uint, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_player_set_xwindow = prototype( ("libvlc_media_player_set_xwindow", dll), paramflags )
libvlc_media_player_set_xwindow.errcheck = check_vlc_exception
libvlc_media_player_set_xwindow.__doc__ = """Set an X Window System drawable where the media player should render its
video output. If LibVLC was built without X11 output support, then this has
no effects.
The specified identifier must correspond to an existing Input/Output class
X11 window. Pixmaps are not supported. The caller shall ensure that
the X11 server is the same as the one the VLC instance has been configured
with.
If XVideo is not used, it is assumed that the drawable has the
following properties in common with the default X11 screen: depth, scan line
pad, black pixel. This is a bug.
@param p_mi the Media Player
@param drawable the ID of the X window
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_get_xwindow'):
prototype=ctypes.CFUNCTYPE(ctypes.c_uint, MediaPlayer)
paramflags=( (1, ), )
libvlc_media_player_get_xwindow = prototype( ("libvlc_media_player_get_xwindow", dll), paramflags )
libvlc_media_player_get_xwindow.__doc__ = """Get the X Window System window identifier previously set with
libvlc_media_player_set_xwindow(). Note that this will return the identifier
even if VLC is not currently using it (for instance if it is playing an
audio-only input).
@return an X window ID, or 0 if none where set.
"""
if hasattr(dll, 'libvlc_media_player_set_hwnd'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_void_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_player_set_hwnd = prototype( ("libvlc_media_player_set_hwnd", dll), paramflags )
libvlc_media_player_set_hwnd.errcheck = check_vlc_exception
libvlc_media_player_set_hwnd.__doc__ = """Set a Win32/Win64 API window handle (HWND) where the media player should
render its video output. If LibVLC was built without Win32/Win64 API output
support, then this has no effects.
@param p_mi the Media Player
@param drawable windows handle of the drawable
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_get_hwnd'):
prototype=ctypes.CFUNCTYPE(ctypes.c_void_p, MediaPlayer)
paramflags=( (1, ), )
libvlc_media_player_get_hwnd = prototype( ("libvlc_media_player_get_hwnd", dll), paramflags )
libvlc_media_player_get_hwnd.__doc__ = """Get the Windows API window handle (HWND) previously set with
libvlc_media_player_set_hwnd(). The handle will be returned even if LibVLC
is not currently outputting any video to it.
@return a window handle or NULL if there are none.
"""
if hasattr(dll, 'libvlc_media_player_get_length'):
prototype=ctypes.CFUNCTYPE(ctypes.c_longlong, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_get_length = prototype( ("libvlc_media_player_get_length", dll), paramflags )
libvlc_media_player_get_length.errcheck = check_vlc_exception
libvlc_media_player_get_length.__doc__ = """Get the current movie length (in ms).
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return the movie length (in ms).
"""
if hasattr(dll, 'libvlc_media_player_get_time'):
prototype=ctypes.CFUNCTYPE(ctypes.c_longlong, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_get_time = prototype( ("libvlc_media_player_get_time", dll), paramflags )
libvlc_media_player_get_time.errcheck = check_vlc_exception
libvlc_media_player_get_time.__doc__ = """Get the current movie time (in ms).
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return the movie time (in ms).
"""
if hasattr(dll, 'libvlc_media_player_set_time'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_longlong, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_player_set_time = prototype( ("libvlc_media_player_set_time", dll), paramflags )
libvlc_media_player_set_time.errcheck = check_vlc_exception
libvlc_media_player_set_time.__doc__ = """Set the movie time (in ms).
@param p_mi the Media Player
@param the movie time (in ms).
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_get_position'):
prototype=ctypes.CFUNCTYPE(ctypes.c_float, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_get_position = prototype( ("libvlc_media_player_get_position", dll), paramflags )
libvlc_media_player_get_position.errcheck = check_vlc_exception
libvlc_media_player_get_position.__doc__ = """Get movie position.
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return movie position
"""
if hasattr(dll, 'libvlc_media_player_set_position'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_float, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_player_set_position = prototype( ("libvlc_media_player_set_position", dll), paramflags )
libvlc_media_player_set_position.errcheck = check_vlc_exception
libvlc_media_player_set_position.__doc__ = """Set movie position.
@param p_mi the Media Player
@param f_pos the position
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_set_chapter'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_player_set_chapter = prototype( ("libvlc_media_player_set_chapter", dll), paramflags )
libvlc_media_player_set_chapter.errcheck = check_vlc_exception
libvlc_media_player_set_chapter.__doc__ = """Set movie chapter
@param p_mi the Media Player
@param i_chapter chapter number to play
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_get_chapter'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_get_chapter = prototype( ("libvlc_media_player_get_chapter", dll), paramflags )
libvlc_media_player_get_chapter.errcheck = check_vlc_exception
libvlc_media_player_get_chapter.__doc__ = """Get movie chapter
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return chapter number currently playing
"""
if hasattr(dll, 'libvlc_media_player_get_chapter_count'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_get_chapter_count = prototype( ("libvlc_media_player_get_chapter_count", dll), paramflags )
libvlc_media_player_get_chapter_count.errcheck = check_vlc_exception
libvlc_media_player_get_chapter_count.__doc__ = """Get movie chapter count
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return number of chapters in movie
"""
if hasattr(dll, 'libvlc_media_player_will_play'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_will_play = prototype( ("libvlc_media_player_will_play", dll), paramflags )
libvlc_media_player_will_play.errcheck = check_vlc_exception
libvlc_media_player_will_play.__doc__ = """Will the player play
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return boolean
"""
if hasattr(dll, 'libvlc_media_player_get_chapter_count_for_title'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_player_get_chapter_count_for_title = prototype( ("libvlc_media_player_get_chapter_count_for_title", dll), paramflags )
libvlc_media_player_get_chapter_count_for_title.errcheck = check_vlc_exception
libvlc_media_player_get_chapter_count_for_title.__doc__ = """Get title chapter count
@param p_mi the Media Player
@param i_title title
@param p_e an initialized exception pointer
@return number of chapters in title
"""
if hasattr(dll, 'libvlc_media_player_set_title'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_player_set_title = prototype( ("libvlc_media_player_set_title", dll), paramflags )
libvlc_media_player_set_title.errcheck = check_vlc_exception
libvlc_media_player_set_title.__doc__ = """Set movie title
@param p_mi the Media Player
@param i_title title number to play
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_get_title'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_get_title = prototype( ("libvlc_media_player_get_title", dll), paramflags )
libvlc_media_player_get_title.errcheck = check_vlc_exception
libvlc_media_player_get_title.__doc__ = """Get movie title
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return title number currently playing
"""
if hasattr(dll, 'libvlc_media_player_get_title_count'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_get_title_count = prototype( ("libvlc_media_player_get_title_count", dll), paramflags )
libvlc_media_player_get_title_count.errcheck = check_vlc_exception
libvlc_media_player_get_title_count.__doc__ = """Get movie title count
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return title number count
"""
if hasattr(dll, 'libvlc_media_player_previous_chapter'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_previous_chapter = prototype( ("libvlc_media_player_previous_chapter", dll), paramflags )
libvlc_media_player_previous_chapter.errcheck = check_vlc_exception
libvlc_media_player_previous_chapter.__doc__ = """Set previous chapter
@param p_mi the Media Player
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_next_chapter'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_next_chapter = prototype( ("libvlc_media_player_next_chapter", dll), paramflags )
libvlc_media_player_next_chapter.errcheck = check_vlc_exception
libvlc_media_player_next_chapter.__doc__ = """Set next chapter
@param p_mi the Media Player
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_get_rate'):
prototype=ctypes.CFUNCTYPE(ctypes.c_float, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_get_rate = prototype( ("libvlc_media_player_get_rate", dll), paramflags )
libvlc_media_player_get_rate.errcheck = check_vlc_exception
libvlc_media_player_get_rate.__doc__ = """Get movie play rate
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return movie play rate
"""
if hasattr(dll, 'libvlc_media_player_set_rate'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_float, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_media_player_set_rate = prototype( ("libvlc_media_player_set_rate", dll), paramflags )
libvlc_media_player_set_rate.errcheck = check_vlc_exception
libvlc_media_player_set_rate.__doc__ = """Set movie play rate
@param p_mi the Media Player
@param movie play rate to set
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_get_state'):
prototype=ctypes.CFUNCTYPE(State, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_get_state = prototype( ("libvlc_media_player_get_state", dll), paramflags )
libvlc_media_player_get_state.errcheck = check_vlc_exception
libvlc_media_player_get_state.__doc__ = """Get current movie state
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return current movie state as libvlc_state_t
"""
if hasattr(dll, 'libvlc_media_player_get_fps'):
prototype=ctypes.CFUNCTYPE(ctypes.c_float, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_get_fps = prototype( ("libvlc_media_player_get_fps", dll), paramflags )
libvlc_media_player_get_fps.errcheck = check_vlc_exception
libvlc_media_player_get_fps.__doc__ = """Get movie fps rate
@param p_mi the Media Player
@param p_e an initialized exception pointer
@return frames per second (fps) for this playing movie
"""
if hasattr(dll, 'libvlc_media_player_has_vout'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_has_vout = prototype( ("libvlc_media_player_has_vout", dll), paramflags )
libvlc_media_player_has_vout.errcheck = check_vlc_exception
libvlc_media_player_has_vout.__doc__ = """Does this media player have a video output?
@param p_md the media player
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_is_seekable'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_is_seekable = prototype( ("libvlc_media_player_is_seekable", dll), paramflags )
libvlc_media_player_is_seekable.errcheck = check_vlc_exception
libvlc_media_player_is_seekable.__doc__ = """Is this media player seekable?
@param p_input the input
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_media_player_can_pause'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_media_player_can_pause = prototype( ("libvlc_media_player_can_pause", dll), paramflags )
libvlc_media_player_can_pause.errcheck = check_vlc_exception
libvlc_media_player_can_pause.__doc__ = """Can this media player be paused?
@param p_input the input
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_track_description_release'):
prototype=ctypes.CFUNCTYPE(None, TrackDescription)
paramflags=( (1, ), )
libvlc_track_description_release = prototype( ("libvlc_track_description_release", dll), paramflags )
libvlc_track_description_release.__doc__ = """Release (free) libvlc_track_description_t
@param p_track_description the structure to release
"""
if hasattr(dll, 'libvlc_toggle_fullscreen'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_toggle_fullscreen = prototype( ("libvlc_toggle_fullscreen", dll), paramflags )
libvlc_toggle_fullscreen.errcheck = check_vlc_exception
libvlc_toggle_fullscreen.__doc__ = """Toggle fullscreen status on video output.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_set_fullscreen'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_set_fullscreen = prototype( ("libvlc_set_fullscreen", dll), paramflags )
libvlc_set_fullscreen.errcheck = check_vlc_exception
libvlc_set_fullscreen.__doc__ = """Enable or disable fullscreen on a video output.
@param p_mediaplayer the media player
@param b_fullscreen boolean for fullscreen status
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_get_fullscreen'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_get_fullscreen = prototype( ("libvlc_get_fullscreen", dll), paramflags )
libvlc_get_fullscreen.errcheck = check_vlc_exception
libvlc_get_fullscreen.__doc__ = """Get current fullscreen status.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
@return the fullscreen status (boolean)
"""
if hasattr(dll, 'libvlc_video_get_height'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_height = prototype( ("libvlc_video_get_height", dll), paramflags )
libvlc_video_get_height.errcheck = check_vlc_exception
libvlc_video_get_height.__doc__ = """Get current video height.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
@return the video height
"""
if hasattr(dll, 'libvlc_video_get_width'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_width = prototype( ("libvlc_video_get_width", dll), paramflags )
libvlc_video_get_width.errcheck = check_vlc_exception
libvlc_video_get_width.__doc__ = """Get current video width.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
@return the video width
"""
if hasattr(dll, 'libvlc_video_get_scale'):
prototype=ctypes.CFUNCTYPE(ctypes.c_float, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_scale = prototype( ("libvlc_video_get_scale", dll), paramflags )
libvlc_video_get_scale.errcheck = check_vlc_exception
libvlc_video_get_scale.__doc__ = """Get the current video scaling factor.
See also libvlc_video_set_scale().
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
@return the currently configured zoom factor, or 0. if the video is set
to fit to the output window/drawable automatically.
"""
if hasattr(dll, 'libvlc_video_set_scale'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_float, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_video_set_scale = prototype( ("libvlc_video_set_scale", dll), paramflags )
libvlc_video_set_scale.errcheck = check_vlc_exception
libvlc_video_set_scale.__doc__ = """Set the video scaling factor. That is the ratio of the number of pixels on
screen to the number of pixels in the original decoded video in each
dimension. Zero is a special value; it will adjust the video to the output
window/drawable (in windowed mode) or the entire screen.
Note that not all video outputs support scaling.
@param p_mediaplayer the media player
@param i_factor the scaling factor, or zero
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_video_get_aspect_ratio'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_aspect_ratio = prototype( ("libvlc_video_get_aspect_ratio", dll), paramflags )
libvlc_video_get_aspect_ratio.errcheck = check_vlc_exception
libvlc_video_get_aspect_ratio.__doc__ = """Get current video aspect ratio.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
@return the video aspect ratio
"""
if hasattr(dll, 'libvlc_video_set_aspect_ratio'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_video_set_aspect_ratio = prototype( ("libvlc_video_set_aspect_ratio", dll), paramflags )
libvlc_video_set_aspect_ratio.errcheck = check_vlc_exception
libvlc_video_set_aspect_ratio.__doc__ = """Set new video aspect ratio.
@param p_mediaplayer the media player
@param psz_aspect new video aspect-ratio
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_video_get_spu'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_spu = prototype( ("libvlc_video_get_spu", dll), paramflags )
libvlc_video_get_spu.errcheck = check_vlc_exception
libvlc_video_get_spu.__doc__ = """Get current video subtitle.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
@return the video subtitle selected
"""
if hasattr(dll, 'libvlc_video_get_spu_count'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_spu_count = prototype( ("libvlc_video_get_spu_count", dll), paramflags )
libvlc_video_get_spu_count.errcheck = check_vlc_exception
libvlc_video_get_spu_count.__doc__ = """Get the number of available video subtitles.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
@return the number of available video subtitles
"""
if hasattr(dll, 'libvlc_video_get_spu_description'):
prototype=ctypes.CFUNCTYPE(TrackDescription, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_spu_description = prototype( ("libvlc_video_get_spu_description", dll), paramflags )
libvlc_video_get_spu_description.errcheck = check_vlc_exception
libvlc_video_get_spu_description.__doc__ = """Get the description of available video subtitles.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
@return list containing description of available video subtitles
"""
if hasattr(dll, 'libvlc_video_set_spu'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_video_set_spu = prototype( ("libvlc_video_set_spu", dll), paramflags )
libvlc_video_set_spu.errcheck = check_vlc_exception
libvlc_video_set_spu.__doc__ = """Set new video subtitle.
@param p_mediaplayer the media player
@param i_spu new video subtitle to select
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_video_set_subtitle_file'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_video_set_subtitle_file = prototype( ("libvlc_video_set_subtitle_file", dll), paramflags )
libvlc_video_set_subtitle_file.errcheck = check_vlc_exception
libvlc_video_set_subtitle_file.__doc__ = """Set new video subtitle file.
@param p_mediaplayer the media player
@param psz_subtitle new video subtitle file
@param p_e an initialized exception pointer
@return the success status (boolean)
"""
if hasattr(dll, 'libvlc_video_get_title_description'):
prototype=ctypes.CFUNCTYPE(TrackDescription, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_title_description = prototype( ("libvlc_video_get_title_description", dll), paramflags )
libvlc_video_get_title_description.errcheck = check_vlc_exception
libvlc_video_get_title_description.__doc__ = """Get the description of available titles.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
@return list containing description of available titles
"""
if hasattr(dll, 'libvlc_video_get_chapter_description'):
prototype=ctypes.CFUNCTYPE(TrackDescription, MediaPlayer, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_video_get_chapter_description = prototype( ("libvlc_video_get_chapter_description", dll), paramflags )
libvlc_video_get_chapter_description.errcheck = check_vlc_exception
libvlc_video_get_chapter_description.__doc__ = """Get the description of available chapters for specific title.
@param p_mediaplayer the media player
@param i_title selected title
@param p_e an initialized exception pointer
@return list containing description of available chapter for title i_title
"""
if hasattr(dll, 'libvlc_video_get_crop_geometry'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_crop_geometry = prototype( ("libvlc_video_get_crop_geometry", dll), paramflags )
libvlc_video_get_crop_geometry.errcheck = check_vlc_exception
libvlc_video_get_crop_geometry.__doc__ = """Get current crop filter geometry.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
@return the crop filter geometry
"""
if hasattr(dll, 'libvlc_video_set_crop_geometry'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_video_set_crop_geometry = prototype( ("libvlc_video_set_crop_geometry", dll), paramflags )
libvlc_video_set_crop_geometry.errcheck = check_vlc_exception
libvlc_video_set_crop_geometry.__doc__ = """Set new crop filter geometry.
@param p_mediaplayer the media player
@param psz_geometry new crop filter geometry
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_toggle_teletext'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_toggle_teletext = prototype( ("libvlc_toggle_teletext", dll), paramflags )
libvlc_toggle_teletext.errcheck = check_vlc_exception
libvlc_toggle_teletext.__doc__ = """Toggle teletext transparent status on video output.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_video_get_teletext'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_teletext = prototype( ("libvlc_video_get_teletext", dll), paramflags )
libvlc_video_get_teletext.errcheck = check_vlc_exception
libvlc_video_get_teletext.__doc__ = """Get current teletext page requested.
@param p_mediaplayer the media player
@param p_e an initialized exception pointer
@return the current teletext page requested.
"""
if hasattr(dll, 'libvlc_video_set_teletext'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_video_set_teletext = prototype( ("libvlc_video_set_teletext", dll), paramflags )
libvlc_video_set_teletext.errcheck = check_vlc_exception
libvlc_video_set_teletext.__doc__ = """Set new teletext page to retrieve.
@param p_mediaplayer the media player
@param i_page teletex page number requested
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_video_get_track_count'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_track_count = prototype( ("libvlc_video_get_track_count", dll), paramflags )
libvlc_video_get_track_count.errcheck = check_vlc_exception
libvlc_video_get_track_count.__doc__ = """Get number of available video tracks.
@param p_mi media player
@param p_e an initialized exception
@return the number of available video tracks (int)
"""
if hasattr(dll, 'libvlc_video_get_track_description'):
prototype=ctypes.CFUNCTYPE(TrackDescription, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_track_description = prototype( ("libvlc_video_get_track_description", dll), paramflags )
libvlc_video_get_track_description.errcheck = check_vlc_exception
libvlc_video_get_track_description.__doc__ = """Get the description of available video tracks.
@param p_mi media player
@param p_e an initialized exception
@return list with description of available video tracks
"""
if hasattr(dll, 'libvlc_video_get_track'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_video_get_track = prototype( ("libvlc_video_get_track", dll), paramflags )
libvlc_video_get_track.errcheck = check_vlc_exception
libvlc_video_get_track.__doc__ = """Get current video track.
@param p_mi media player
@param p_e an initialized exception pointer
@return the video track (int)
"""
if hasattr(dll, 'libvlc_video_set_track'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_video_set_track = prototype( ("libvlc_video_set_track", dll), paramflags )
libvlc_video_set_track.errcheck = check_vlc_exception
libvlc_video_set_track.__doc__ = """Set video track.
@param p_mi media player
@param i_track the track (int)
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_video_take_snapshot'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_char_p, ctypes.c_uint, ctypes.c_uint, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (1,), (3,)
libvlc_video_take_snapshot = prototype( ("libvlc_video_take_snapshot", dll), paramflags )
libvlc_video_take_snapshot.errcheck = check_vlc_exception
libvlc_video_take_snapshot.__doc__ = """Take a snapshot of the current video window.
If i_width AND i_height is 0, original size is used.
If i_width XOR i_height is 0, original aspect-ratio is preserved.
@param p_mi media player instance
@param psz_filepath the path where to save the screenshot to
@param i_width the snapshot's width
@param i_height the snapshot's height
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_audio_output_list_get'):
prototype=ctypes.CFUNCTYPE(AudioOutput, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_audio_output_list_get = prototype( ("libvlc_audio_output_list_get", dll), paramflags )
libvlc_audio_output_list_get.errcheck = check_vlc_exception
libvlc_audio_output_list_get.__doc__ = """Get the list of available audio outputs
@param p_instance libvlc instance
@param p_e an initialized exception pointer
@return list of available audio outputs, at the end free it with
"""
if hasattr(dll, 'libvlc_audio_output_list_release'):
prototype=ctypes.CFUNCTYPE(None, AudioOutput)
paramflags=( (1, ), )
libvlc_audio_output_list_release = prototype( ("libvlc_audio_output_list_release", dll), paramflags )
libvlc_audio_output_list_release.__doc__ = """Free the list of available audio outputs
@param p_list list with audio outputs for release
"""
if hasattr(dll, 'libvlc_audio_output_set'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.c_char_p)
paramflags=(1,), (1,)
libvlc_audio_output_set = prototype( ("libvlc_audio_output_set", dll), paramflags )
libvlc_audio_output_set.__doc__ = """Set the audio output.
Change will be applied after stop and play.
@param p_instance libvlc instance
@param psz_name name of audio output,
use psz_name of \see libvlc_audio_output_t
@return true if function succeded
"""
if hasattr(dll, 'libvlc_audio_output_device_count'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.c_char_p)
paramflags=(1,), (1,)
libvlc_audio_output_device_count = prototype( ("libvlc_audio_output_device_count", dll), paramflags )
libvlc_audio_output_device_count.__doc__ = """Get count of devices for audio output, these devices are hardware oriented
like analor or digital output of sound card
@param p_instance libvlc instance
@param psz_audio_output - name of audio output, \see libvlc_audio_output_t
@return number of devices
"""
if hasattr(dll, 'libvlc_audio_output_device_longname'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p, Instance, ctypes.c_char_p, ctypes.c_int)
paramflags=(1,), (1,), (1,)
libvlc_audio_output_device_longname = prototype( ("libvlc_audio_output_device_longname", dll), paramflags )
libvlc_audio_output_device_longname.__doc__ = """Get long name of device, if not available short name given
@param p_instance libvlc instance
@param psz_audio_output - name of audio output, \see libvlc_audio_output_t
@param i_device device index
@return long name of device
"""
if hasattr(dll, 'libvlc_audio_output_device_id'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p, Instance, ctypes.c_char_p, ctypes.c_int)
paramflags=(1,), (1,), (1,)
libvlc_audio_output_device_id = prototype( ("libvlc_audio_output_device_id", dll), paramflags )
libvlc_audio_output_device_id.__doc__ = """Get id name of device
@param p_instance libvlc instance
@param psz_audio_output - name of audio output, \see libvlc_audio_output_t
@param i_device device index
@return id name of device, use for setting device, need to be free after use
"""
if hasattr(dll, 'libvlc_audio_output_device_set'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.c_char_p)
paramflags=(1,), (1,), (1,)
libvlc_audio_output_device_set = prototype( ("libvlc_audio_output_device_set", dll), paramflags )
libvlc_audio_output_device_set.__doc__ = """Set device for using
@param p_instance libvlc instance
@param psz_audio_output - name of audio output, \see libvlc_audio_output_t
@param psz_device_id device
"""
if hasattr(dll, 'libvlc_audio_output_get_device_type'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_audio_output_get_device_type = prototype( ("libvlc_audio_output_get_device_type", dll), paramflags )
libvlc_audio_output_get_device_type.errcheck = check_vlc_exception
libvlc_audio_output_get_device_type.__doc__ = """Get current audio device type. Device type describes something like
character of output sound - stereo sound, 2.1, 5.1 etc
@param p_instance vlc instance
@param p_e an initialized exception pointer
@return the audio devices type \see libvlc_audio_output_device_types_t
"""
if hasattr(dll, 'libvlc_audio_output_set_device_type'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_audio_output_set_device_type = prototype( ("libvlc_audio_output_set_device_type", dll), paramflags )
libvlc_audio_output_set_device_type.errcheck = check_vlc_exception
libvlc_audio_output_set_device_type.__doc__ = """Set current audio device type.
@param p_instance vlc instance
@param device_type the audio device type,
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_audio_toggle_mute'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_audio_toggle_mute = prototype( ("libvlc_audio_toggle_mute", dll), paramflags )
libvlc_audio_toggle_mute.errcheck = check_vlc_exception
libvlc_audio_toggle_mute.__doc__ = """Toggle mute status.
@param p_instance libvlc instance
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_audio_get_mute'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_audio_get_mute = prototype( ("libvlc_audio_get_mute", dll), paramflags )
libvlc_audio_get_mute.errcheck = check_vlc_exception
libvlc_audio_get_mute.__doc__ = """Get current mute status.
@param p_instance libvlc instance
@param p_e an initialized exception pointer
@return the mute status (boolean)
"""
if hasattr(dll, 'libvlc_audio_set_mute'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_audio_set_mute = prototype( ("libvlc_audio_set_mute", dll), paramflags )
libvlc_audio_set_mute.errcheck = check_vlc_exception
libvlc_audio_set_mute.__doc__ = """Set mute status.
@param p_instance libvlc instance
@param status If status is true then mute, otherwise unmute
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_audio_get_volume'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_audio_get_volume = prototype( ("libvlc_audio_get_volume", dll), paramflags )
libvlc_audio_get_volume.errcheck = check_vlc_exception
libvlc_audio_get_volume.__doc__ = """Get current audio level.
@param p_instance libvlc instance
@param p_e an initialized exception pointer
@return the audio level (int)
"""
if hasattr(dll, 'libvlc_audio_set_volume'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_audio_set_volume = prototype( ("libvlc_audio_set_volume", dll), paramflags )
libvlc_audio_set_volume.errcheck = check_vlc_exception
libvlc_audio_set_volume.__doc__ = """Set current audio level.
@param p_instance libvlc instance
@param i_volume the volume (int)
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_audio_get_track_count'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_audio_get_track_count = prototype( ("libvlc_audio_get_track_count", dll), paramflags )
libvlc_audio_get_track_count.errcheck = check_vlc_exception
libvlc_audio_get_track_count.__doc__ = """Get number of available audio tracks.
@param p_mi media player
@param p_e an initialized exception
@return the number of available audio tracks (int)
"""
if hasattr(dll, 'libvlc_audio_get_track_description'):
prototype=ctypes.CFUNCTYPE(TrackDescription, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_audio_get_track_description = prototype( ("libvlc_audio_get_track_description", dll), paramflags )
libvlc_audio_get_track_description.errcheck = check_vlc_exception
libvlc_audio_get_track_description.__doc__ = """Get the description of available audio tracks.
@param p_mi media player
@param p_e an initialized exception
@return list with description of available audio tracks
"""
if hasattr(dll, 'libvlc_audio_get_track'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaPlayer, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_audio_get_track = prototype( ("libvlc_audio_get_track", dll), paramflags )
libvlc_audio_get_track.errcheck = check_vlc_exception
libvlc_audio_get_track.__doc__ = """Get current audio track.
@param p_mi media player
@param p_e an initialized exception pointer
@return the audio track (int)
"""
if hasattr(dll, 'libvlc_audio_set_track'):
prototype=ctypes.CFUNCTYPE(None, MediaPlayer, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_audio_set_track = prototype( ("libvlc_audio_set_track", dll), paramflags )
libvlc_audio_set_track.errcheck = check_vlc_exception
libvlc_audio_set_track.__doc__ = """Set current audio track.
@param p_mi media player
@param i_track the track (int)
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_audio_get_channel'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_audio_get_channel = prototype( ("libvlc_audio_get_channel", dll), paramflags )
libvlc_audio_get_channel.errcheck = check_vlc_exception
libvlc_audio_get_channel.__doc__ = """Get current audio channel.
@param p_instance vlc instance
@param p_e an initialized exception pointer
@return the audio channel \see libvlc_audio_output_channel_t
"""
if hasattr(dll, 'libvlc_audio_set_channel'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_audio_set_channel = prototype( ("libvlc_audio_set_channel", dll), paramflags )
libvlc_audio_set_channel.errcheck = check_vlc_exception
libvlc_audio_set_channel.__doc__ = """Set current audio channel.
@param p_instance vlc instance
@param channel the audio channel, \see libvlc_audio_output_channel_t
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_release'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.POINTER(VLCException))
paramflags=(1,), (3,)
libvlc_vlm_release = prototype( ("libvlc_vlm_release", dll), paramflags )
libvlc_vlm_release.errcheck = check_vlc_exception
libvlc_vlm_release.__doc__ = """Release the vlm instance related to the given libvlc_instance_t
@param p_instance the instance
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_add_broadcast'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int, ListPOINTER(ctypes.c_char_p), ctypes.c_int, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), (3,)
libvlc_vlm_add_broadcast = prototype( ("libvlc_vlm_add_broadcast", dll), paramflags )
libvlc_vlm_add_broadcast.errcheck = check_vlc_exception
libvlc_vlm_add_broadcast.__doc__ = """Add a broadcast, with one input.
@param p_instance the instance
@param psz_name the name of the new broadcast
@param psz_input the input MRL
@param psz_output the output MRL (the parameter to the "sout" variable)
@param i_options number of additional options
@param ppsz_options additional options
@param b_enabled boolean for enabling the new broadcast
@param b_loop Should this broadcast be played in loop ?
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_add_vod'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int, ListPOINTER(ctypes.c_char_p), ctypes.c_int, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (1,), (1,), (1,), (1,), (3,)
libvlc_vlm_add_vod = prototype( ("libvlc_vlm_add_vod", dll), paramflags )
libvlc_vlm_add_vod.errcheck = check_vlc_exception
libvlc_vlm_add_vod.__doc__ = """Add a vod, with one input.
@param p_instance the instance
@param psz_name the name of the new vod media
@param psz_input the input MRL
@param i_options number of additional options
@param ppsz_options additional options
@param b_enabled boolean for enabling the new vod
@param psz_mux the muxer of the vod media
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_del_media'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_vlm_del_media = prototype( ("libvlc_vlm_del_media", dll), paramflags )
libvlc_vlm_del_media.errcheck = check_vlc_exception
libvlc_vlm_del_media.__doc__ = """Delete a media (VOD or broadcast).
@param p_instance the instance
@param psz_name the media to delete
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_set_enabled'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_set_enabled = prototype( ("libvlc_vlm_set_enabled", dll), paramflags )
libvlc_vlm_set_enabled.errcheck = check_vlc_exception
libvlc_vlm_set_enabled.__doc__ = """Enable or disable a media (VOD or broadcast).
@param p_instance the instance
@param psz_name the media to work on
@param b_enabled the new status
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_set_output'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_set_output = prototype( ("libvlc_vlm_set_output", dll), paramflags )
libvlc_vlm_set_output.errcheck = check_vlc_exception
libvlc_vlm_set_output.__doc__ = """Set the output for a media.
@param p_instance the instance
@param psz_name the media to work on
@param psz_output the output MRL (the parameter to the "sout" variable)
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_set_input'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_set_input = prototype( ("libvlc_vlm_set_input", dll), paramflags )
libvlc_vlm_set_input.errcheck = check_vlc_exception
libvlc_vlm_set_input.__doc__ = """Set a media's input MRL. This will delete all existing inputs and
add the specified one.
@param p_instance the instance
@param psz_name the media to work on
@param psz_input the input MRL
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_add_input'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_add_input = prototype( ("libvlc_vlm_add_input", dll), paramflags )
libvlc_vlm_add_input.errcheck = check_vlc_exception
libvlc_vlm_add_input.__doc__ = """Add a media's input MRL. This will add the specified one.
@param p_instance the instance
@param psz_name the media to work on
@param psz_input the input MRL
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_set_loop'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_set_loop = prototype( ("libvlc_vlm_set_loop", dll), paramflags )
libvlc_vlm_set_loop.errcheck = check_vlc_exception
libvlc_vlm_set_loop.__doc__ = """Set a media's loop status.
@param p_instance the instance
@param psz_name the media to work on
@param b_loop the new status
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_set_mux'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_set_mux = prototype( ("libvlc_vlm_set_mux", dll), paramflags )
libvlc_vlm_set_mux.errcheck = check_vlc_exception
libvlc_vlm_set_mux.__doc__ = """Set a media's vod muxer.
@param p_instance the instance
@param psz_name the media to work on
@param psz_mux the new muxer
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_change_media'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int, ListPOINTER(ctypes.c_char_p), ctypes.c_int, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (1,), (1,), (1,), (1,), (1,), (3,)
libvlc_vlm_change_media = prototype( ("libvlc_vlm_change_media", dll), paramflags )
libvlc_vlm_change_media.errcheck = check_vlc_exception
libvlc_vlm_change_media.__doc__ = """Edit the parameters of a media. This will delete all existing inputs and
add the specified one.
@param p_instance the instance
@param psz_name the name of the new broadcast
@param psz_input the input MRL
@param psz_output the output MRL (the parameter to the "sout" variable)
@param i_options number of additional options
@param ppsz_options additional options
@param b_enabled boolean for enabling the new broadcast
@param b_loop Should this broadcast be played in loop ?
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_play_media'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_vlm_play_media = prototype( ("libvlc_vlm_play_media", dll), paramflags )
libvlc_vlm_play_media.errcheck = check_vlc_exception
libvlc_vlm_play_media.__doc__ = """Play the named broadcast.
@param p_instance the instance
@param psz_name the name of the broadcast
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_stop_media'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_vlm_stop_media = prototype( ("libvlc_vlm_stop_media", dll), paramflags )
libvlc_vlm_stop_media.errcheck = check_vlc_exception
libvlc_vlm_stop_media.__doc__ = """Stop the named broadcast.
@param p_instance the instance
@param psz_name the name of the broadcast
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_pause_media'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_vlm_pause_media = prototype( ("libvlc_vlm_pause_media", dll), paramflags )
libvlc_vlm_pause_media.errcheck = check_vlc_exception
libvlc_vlm_pause_media.__doc__ = """Pause the named broadcast.
@param p_instance the instance
@param psz_name the name of the broadcast
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_seek_media'):
prototype=ctypes.CFUNCTYPE(None, Instance, ctypes.c_char_p, ctypes.c_float, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_seek_media = prototype( ("libvlc_vlm_seek_media", dll), paramflags )
libvlc_vlm_seek_media.errcheck = check_vlc_exception
libvlc_vlm_seek_media.__doc__ = """Seek in the named broadcast.
@param p_instance the instance
@param psz_name the name of the broadcast
@param f_percentage the percentage to seek to
@param p_e an initialized exception pointer
"""
if hasattr(dll, 'libvlc_vlm_show_media'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p, Instance, ctypes.c_char_p, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (3,)
libvlc_vlm_show_media = prototype( ("libvlc_vlm_show_media", dll), paramflags )
libvlc_vlm_show_media.errcheck = check_vlc_exception
libvlc_vlm_show_media.__doc__ = """Return information about the named broadcast.
\bug will always return NULL
@param p_instance the instance
@param psz_name the name of the broadcast
@param p_e an initialized exception pointer
@return string with information about named media
"""
if hasattr(dll, 'libvlc_vlm_get_media_instance_position'):
prototype=ctypes.CFUNCTYPE(ctypes.c_float, Instance, ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_get_media_instance_position = prototype( ("libvlc_vlm_get_media_instance_position", dll), paramflags )
libvlc_vlm_get_media_instance_position.errcheck = check_vlc_exception
libvlc_vlm_get_media_instance_position.__doc__ = """Get vlm_media instance position by name or instance id
@param p_instance a libvlc instance
@param psz_name name of vlm media instance
@param i_instance instance id
@param p_e an initialized exception pointer
@return position as float
"""
if hasattr(dll, 'libvlc_vlm_get_media_instance_time'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_get_media_instance_time = prototype( ("libvlc_vlm_get_media_instance_time", dll), paramflags )
libvlc_vlm_get_media_instance_time.errcheck = check_vlc_exception
libvlc_vlm_get_media_instance_time.__doc__ = """Get vlm_media instance time by name or instance id
@param p_instance a libvlc instance
@param psz_name name of vlm media instance
@param i_instance instance id
@param p_e an initialized exception pointer
@return time as integer
"""
if hasattr(dll, 'libvlc_vlm_get_media_instance_length'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_get_media_instance_length = prototype( ("libvlc_vlm_get_media_instance_length", dll), paramflags )
libvlc_vlm_get_media_instance_length.errcheck = check_vlc_exception
libvlc_vlm_get_media_instance_length.__doc__ = """Get vlm_media instance length by name or instance id
@param p_instance a libvlc instance
@param psz_name name of vlm media instance
@param i_instance instance id
@param p_e an initialized exception pointer
@return length of media item
"""
if hasattr(dll, 'libvlc_vlm_get_media_instance_rate'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_get_media_instance_rate = prototype( ("libvlc_vlm_get_media_instance_rate", dll), paramflags )
libvlc_vlm_get_media_instance_rate.errcheck = check_vlc_exception
libvlc_vlm_get_media_instance_rate.__doc__ = """Get vlm_media instance playback rate by name or instance id
@param p_instance a libvlc instance
@param psz_name name of vlm media instance
@param i_instance instance id
@param p_e an initialized exception pointer
@return playback rate
"""
if hasattr(dll, 'libvlc_vlm_get_media_instance_title'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_get_media_instance_title = prototype( ("libvlc_vlm_get_media_instance_title", dll), paramflags )
libvlc_vlm_get_media_instance_title.errcheck = check_vlc_exception
libvlc_vlm_get_media_instance_title.__doc__ = """Get vlm_media instance title number by name or instance id
\bug will always return 0
@param p_instance a libvlc instance
@param psz_name name of vlm media instance
@param i_instance instance id
@param p_e an initialized exception pointer
@return title as number
"""
if hasattr(dll, 'libvlc_vlm_get_media_instance_chapter'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_get_media_instance_chapter = prototype( ("libvlc_vlm_get_media_instance_chapter", dll), paramflags )
libvlc_vlm_get_media_instance_chapter.errcheck = check_vlc_exception
libvlc_vlm_get_media_instance_chapter.__doc__ = """Get vlm_media instance chapter number by name or instance id
\bug will always return 0
@param p_instance a libvlc instance
@param psz_name name of vlm media instance
@param i_instance instance id
@param p_e an initialized exception pointer
@return chapter as number
"""
if hasattr(dll, 'libvlc_vlm_get_media_instance_seekable'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, Instance, ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(VLCException))
paramflags=(1,), (1,), (1,), (3,)
libvlc_vlm_get_media_instance_seekable = prototype( ("libvlc_vlm_get_media_instance_seekable", dll), paramflags )
libvlc_vlm_get_media_instance_seekable.errcheck = check_vlc_exception
libvlc_vlm_get_media_instance_seekable.__doc__ = """Is libvlc instance seekable ?
\bug will always return 0
@param p_instance a libvlc instance
@param psz_name name of vlm media instance
@param i_instance instance id
@param p_e an initialized exception pointer
@return 1 if seekable, 0 if not
"""
if hasattr(dll, 'mediacontrol_RGBPicture__free'):
prototype=ctypes.CFUNCTYPE(None, ctypes.POINTER(RGBPicture))
paramflags=( (1, ), )
mediacontrol_RGBPicture__free = prototype( ("mediacontrol_RGBPicture__free", dll), paramflags )
mediacontrol_RGBPicture__free.__doc__ = """Free a RGBPicture structure.
@param pic: the RGBPicture structure
"""
if hasattr(dll, 'mediacontrol_StreamInformation__free'):
prototype=ctypes.CFUNCTYPE(None, ctypes.POINTER(MediaControlStreamInformation))
paramflags=( (1, ), )
mediacontrol_StreamInformation__free = prototype( ("mediacontrol_StreamInformation__free", dll), paramflags )
mediacontrol_StreamInformation__free.__doc__ = """Free a StreamInformation structure.
@param pic: the StreamInformation structure
"""
if hasattr(dll, 'mediacontrol_exception_create'):
prototype=ctypes.CFUNCTYPE(MediaControlException)
paramflags= tuple()
mediacontrol_exception_create = prototype( ("mediacontrol_exception_create", dll), paramflags )
mediacontrol_exception_create.__doc__ = """Instanciate and initialize an exception structure.
@return the exception
"""
if hasattr(dll, 'mediacontrol_exception_init'):
prototype=ctypes.CFUNCTYPE(None, MediaControlException)
paramflags=( (1, ), )
mediacontrol_exception_init = prototype( ("mediacontrol_exception_init", dll), paramflags )
mediacontrol_exception_init.__doc__ = """Initialize an existing exception structure.
@param p_exception the exception to initialize.
"""
if hasattr(dll, 'mediacontrol_exception_cleanup'):
prototype=ctypes.CFUNCTYPE(None, MediaControlException)
paramflags=( (1, ), )
mediacontrol_exception_cleanup = prototype( ("mediacontrol_exception_cleanup", dll), paramflags )
mediacontrol_exception_cleanup.__doc__ = """Clean up an existing exception structure after use.
@param p_exception the exception to clean up.
"""
if hasattr(dll, 'mediacontrol_exception_free'):
prototype=ctypes.CFUNCTYPE(None, MediaControlException)
paramflags=( (1, ), )
mediacontrol_exception_free = prototype( ("mediacontrol_exception_free", dll), paramflags )
mediacontrol_exception_free.__doc__ = """Free an exception structure created with mediacontrol_exception_create().
@return the exception
"""
if hasattr(dll, 'mediacontrol_new'):
prototype=ctypes.CFUNCTYPE(MediaControl, ctypes.c_int, ListPOINTER(ctypes.c_char_p), MediaControlException)
paramflags=(1,), (1,), (1,)
mediacontrol_new = prototype( ("mediacontrol_new", dll), paramflags )
mediacontrol_new.__doc__ = """Create a MediaControl instance with parameters
@param argc the number of arguments
@param argv parameters
@param exception an initialized exception pointer
@return a mediacontrol_Instance
"""
if hasattr(dll, 'mediacontrol_new_from_instance'):
prototype=ctypes.CFUNCTYPE(MediaControl, Instance, MediaControlException)
paramflags=(1,), (1,)
mediacontrol_new_from_instance = prototype( ("mediacontrol_new_from_instance", dll), paramflags )
mediacontrol_new_from_instance.__doc__ = """Create a MediaControl instance from an existing libvlc instance
@param p_instance the libvlc instance
@param exception an initialized exception pointer
@return a mediacontrol_Instance
"""
if hasattr(dll, 'mediacontrol_get_libvlc_instance'):
prototype=ctypes.CFUNCTYPE(Instance, MediaControl)
paramflags=( (1, ), )
mediacontrol_get_libvlc_instance = prototype( ("mediacontrol_get_libvlc_instance", dll), paramflags )
mediacontrol_get_libvlc_instance.__doc__ = """Get the associated libvlc instance
@param self: the mediacontrol instance
@return a libvlc instance
"""
if hasattr(dll, 'mediacontrol_get_media_player'):
prototype=ctypes.CFUNCTYPE(MediaPlayer, MediaControl)
paramflags=( (1, ), )
mediacontrol_get_media_player = prototype( ("mediacontrol_get_media_player", dll), paramflags )
mediacontrol_get_media_player.__doc__ = """Get the associated libvlc_media_player
@param self: the mediacontrol instance
@return a libvlc_media_player_t instance
"""
if hasattr(dll, 'mediacontrol_get_media_position'):
prototype=ctypes.CFUNCTYPE(ctypes.POINTER(MediaControlPosition), MediaControl, PositionOrigin, PositionKey, MediaControlException)
paramflags=(1,), (1,), (1,), (1,)
mediacontrol_get_media_position = prototype( ("mediacontrol_get_media_position", dll), paramflags )
mediacontrol_get_media_position.__doc__ = """Get the current position
@param self the mediacontrol instance
@param an_origin the position origin
@param a_key the position unit
@param exception an initialized exception pointer
@return a mediacontrol_Position
"""
if hasattr(dll, 'mediacontrol_set_media_position'):
prototype=ctypes.CFUNCTYPE(None, MediaControl, ctypes.POINTER(MediaControlPosition), MediaControlException)
paramflags=(1,), (1,), (1,)
mediacontrol_set_media_position = prototype( ("mediacontrol_set_media_position", dll), paramflags )
mediacontrol_set_media_position.__doc__ = """Set the position
@param self the mediacontrol instance
@param a_position a mediacontrol_Position
@param exception an initialized exception pointer
"""
if hasattr(dll, 'mediacontrol_start'):
prototype=ctypes.CFUNCTYPE(None, MediaControl, ctypes.POINTER(MediaControlPosition), MediaControlException)
paramflags=(1,), (1,), (1,)
mediacontrol_start = prototype( ("mediacontrol_start", dll), paramflags )
mediacontrol_start.__doc__ = """Play the movie at a given position
@param self the mediacontrol instance
@param a_position a mediacontrol_Position
@param exception an initialized exception pointer
"""
if hasattr(dll, 'mediacontrol_pause'):
prototype=ctypes.CFUNCTYPE(None, MediaControl, MediaControlException)
paramflags=(1,), (1,)
mediacontrol_pause = prototype( ("mediacontrol_pause", dll), paramflags )
mediacontrol_pause.__doc__ = """Pause the movie at a given position
@param self the mediacontrol instance
@param exception an initialized exception pointer
"""
if hasattr(dll, 'mediacontrol_resume'):
prototype=ctypes.CFUNCTYPE(None, MediaControl, MediaControlException)
paramflags=(1,), (1,)
mediacontrol_resume = prototype( ("mediacontrol_resume", dll), paramflags )
mediacontrol_resume.__doc__ = """Resume the movie at a given position
@param self the mediacontrol instance
@param exception an initialized exception pointer
"""
if hasattr(dll, 'mediacontrol_stop'):
prototype=ctypes.CFUNCTYPE(None, MediaControl, MediaControlException)
paramflags=(1,), (1,)
mediacontrol_stop = prototype( ("mediacontrol_stop", dll), paramflags )
mediacontrol_stop.__doc__ = """Stop the movie at a given position
@param self the mediacontrol instance
@param exception an initialized exception pointer
"""
if hasattr(dll, 'mediacontrol_exit'):
prototype=ctypes.CFUNCTYPE(None, MediaControl)
paramflags=( (1, ), )
mediacontrol_exit = prototype( ("mediacontrol_exit", dll), paramflags )
mediacontrol_exit.__doc__ = """Exit the player
@param self the mediacontrol instance
"""
if hasattr(dll, 'mediacontrol_set_mrl'):
prototype=ctypes.CFUNCTYPE(None, MediaControl, ctypes.c_char_p, MediaControlException)
paramflags=(1,), (1,), (1,)
mediacontrol_set_mrl = prototype( ("mediacontrol_set_mrl", dll), paramflags )
mediacontrol_set_mrl.__doc__ = """Set the MRL to be played.
@param self the mediacontrol instance
@param psz_file the MRL
@param exception an initialized exception pointer
"""
if hasattr(dll, 'mediacontrol_get_mrl'):
prototype=ctypes.CFUNCTYPE(ctypes.c_char_p, MediaControl, MediaControlException)
paramflags=(1,), (1,)
mediacontrol_get_mrl = prototype( ("mediacontrol_get_mrl", dll), paramflags )
mediacontrol_get_mrl.__doc__ = """Get the MRL to be played.
@param self the mediacontrol instance
@param exception an initialized exception pointer
"""
if hasattr(dll, 'mediacontrol_snapshot'):
prototype=ctypes.CFUNCTYPE(ctypes.POINTER(RGBPicture), MediaControl, ctypes.POINTER(MediaControlPosition), MediaControlException)
paramflags=(1,), (1,), (1,)
mediacontrol_snapshot = prototype( ("mediacontrol_snapshot", dll), paramflags )
mediacontrol_snapshot.__doc__ = """Get a snapshot
@param self the mediacontrol instance
@param a_position the desired position (ignored for now)
@param exception an initialized exception pointer
@return a RGBpicture
"""
if hasattr(dll, 'mediacontrol_display_text'):
prototype=ctypes.CFUNCTYPE(None, MediaControl, ctypes.c_char_p, ctypes.POINTER(MediaControlPosition), ctypes.POINTER(MediaControlPosition), MediaControlException)
paramflags=(1,), (1,), (1,), (1,), (1,)
mediacontrol_display_text = prototype( ("mediacontrol_display_text", dll), paramflags )
mediacontrol_display_text.__doc__ = """ Displays the message string, between "begin" and "end" positions.
@param self the mediacontrol instance
@param message the message to display
@param begin the begin position
@param end the end position
@param exception an initialized exception pointer
"""
if hasattr(dll, 'mediacontrol_get_stream_information'):
prototype=ctypes.CFUNCTYPE(ctypes.POINTER(MediaControlStreamInformation), MediaControl, PositionKey, MediaControlException)
paramflags=(1,), (1,), (1,)
mediacontrol_get_stream_information = prototype( ("mediacontrol_get_stream_information", dll), paramflags )
mediacontrol_get_stream_information.__doc__ = """ Get information about a stream
@param self the mediacontrol instance
@param a_key the time unit
@param exception an initialized exception pointer
@return a mediacontrol_StreamInformation
"""
if hasattr(dll, 'mediacontrol_sound_get_volume'):
prototype=ctypes.CFUNCTYPE(ctypes.c_short, MediaControl, MediaControlException)
paramflags=(1,), (1,)
mediacontrol_sound_get_volume = prototype( ("mediacontrol_sound_get_volume", dll), paramflags )
mediacontrol_sound_get_volume.__doc__ = """Get the current audio level, normalized in [0..100]
@param self the mediacontrol instance
@param exception an initialized exception pointer
@return the volume
"""
if hasattr(dll, 'mediacontrol_sound_set_volume'):
prototype=ctypes.CFUNCTYPE(None, MediaControl, ctypes.c_short, MediaControlException)
paramflags=(1,), (1,), (1,)
mediacontrol_sound_set_volume = prototype( ("mediacontrol_sound_set_volume", dll), paramflags )
mediacontrol_sound_set_volume.__doc__ = """Set the audio level
@param self the mediacontrol instance
@param volume the volume (normalized in [0..100])
@param exception an initialized exception pointer
"""
if hasattr(dll, 'mediacontrol_set_visual'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaControl, ctypes.c_ulong, MediaControlException)
paramflags=(1,), (1,), (1,)
mediacontrol_set_visual = prototype( ("mediacontrol_set_visual", dll), paramflags )
mediacontrol_set_visual.__doc__ = """Set the video output window
@param self the mediacontrol instance
@param visual_id the Xid or HWND, depending on the platform
@param exception an initialized exception pointer
"""
if hasattr(dll, 'mediacontrol_get_rate'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaControl, MediaControlException)
paramflags=(1,), (1,)
mediacontrol_get_rate = prototype( ("mediacontrol_get_rate", dll), paramflags )
mediacontrol_get_rate.__doc__ = """Get the current playing rate, in percent
@param self the mediacontrol instance
@param exception an initialized exception pointer
@return the rate
"""
if hasattr(dll, 'mediacontrol_set_rate'):
prototype=ctypes.CFUNCTYPE(None, MediaControl, ctypes.c_int, MediaControlException)
paramflags=(1,), (1,), (1,)
mediacontrol_set_rate = prototype( ("mediacontrol_set_rate", dll), paramflags )
mediacontrol_set_rate.__doc__ = """Set the playing rate, in percent
@param self the mediacontrol instance
@param rate the desired rate
@param exception an initialized exception pointer
"""
if hasattr(dll, 'mediacontrol_get_fullscreen'):
prototype=ctypes.CFUNCTYPE(ctypes.c_int, MediaControl, MediaControlException)
paramflags=(1,), (1,)
mediacontrol_get_fullscreen = prototype( ("mediacontrol_get_fullscreen", dll), paramflags )
mediacontrol_get_fullscreen.__doc__ = """Get current fullscreen status
@param self the mediacontrol instance
@param exception an initialized exception pointer
@return the fullscreen status
"""
if hasattr(dll, 'mediacontrol_set_fullscreen'):
prototype=ctypes.CFUNCTYPE(None, MediaControl, ctypes.c_int, MediaControlException)
paramflags=(1,), (1,), (1,)
mediacontrol_set_fullscreen = prototype( ("mediacontrol_set_fullscreen", dll), paramflags )
mediacontrol_set_fullscreen.__doc__ = """Set fullscreen status
@param self the mediacontrol instance
@param b_fullscreen the desired status
@param exception an initialized exception pointer
"""
### Start of footer.py ###
class MediaEvent(ctypes.Structure):
_fields_ = [
('media_name', ctypes.c_char_p),
('instance_name', ctypes.c_char_p),
]
class EventUnion(ctypes.Union):
_fields_ = [
('meta_type', ctypes.c_uint),
('new_child', ctypes.c_uint),
('new_duration', ctypes.c_longlong),
('new_status', ctypes.c_int),
('media', ctypes.c_void_p),
('new_state', ctypes.c_uint),
# Media instance
('new_position', ctypes.c_float),
('new_time', ctypes.c_longlong),
('new_title', ctypes.c_int),
('new_seekable', ctypes.c_longlong),
('new_pausable', ctypes.c_longlong),
# FIXME: Skipped MediaList and MediaListView...
('filename', ctypes.c_char_p),
('new_length', ctypes.c_longlong),
('media_event', MediaEvent),
]
class Event(ctypes.Structure):
_fields_ = [
('type', EventType),
('object', ctypes.c_void_p),
('u', EventUnion),
]
# Decorator for callback methods
callbackmethod=ctypes.CFUNCTYPE(None, Event, ctypes.c_void_p)
# Example callback method
@callbackmethod
def debug_callback(event, data):
print "Debug callback method"
print "Event:", event.type
print "Data", data
if __name__ == '__main__':
try:
from msvcrt import getch
except ImportError:
def getch():
import tty
import termios
fd=sys.stdin.fileno()
old_settings=termios.tcgetattr(fd)
try:
tty.setraw(fd)
ch=sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
@callbackmethod
def end_callback(event, data):
print "End of stream"
sys.exit(0)
if sys.argv[1:]:
instance=Instance()
media=instance.media_new(sys.argv[1])
player=instance.media_player_new()
player.set_media(media)
player.play()
event_manager=player.event_manager()
event_manager.event_attach(EventType.MediaPlayerEndReached, end_callback, None)
def print_info():
"""Print information about the media."""
media=player.get_media()
print "State:", player.get_state()
print "Media:", media.get_mrl()
try:
print "Current time:", player.get_time(), "/", media.get_duration()
print "Position:", player.get_position()
print "FPS:", player.get_fps()
print "Rate:", player.get_rate()
print "Video size: (%d, %d)" % (player.video_get_width(), player.video_get_height())
except Exception:
pass
def forward():
"""Go forward 1s"""
player.set_time(player.get_time() + 1000)
def one_frame_forward():
"""Go forward one frame"""
player.set_time(player.get_time() + long(1000 / (player.get_fps() or 25)))
def one_frame_backward():
"""Go backward one frame"""
player.set_time(player.get_time() - long(1000 / (player.get_fps() or 25)))
def backward():
"""Go backward 1s"""
player.set_time(player.get_time() - 1000)
def print_help():
"""Print help
"""
print "Commands:"
for k, m in keybindings.iteritems():
print " %s: %s" % (k, (m.__doc__ or m.__name__).splitlines()[0])
print " 1-9: go to the given fraction of the movie"
def quit_app():
"""Exit."""
sys.exit(0)
keybindings={
'f': player.toggle_fullscreen,
' ': player.pause,
'+': forward,
'-': backward,
'.': one_frame_forward,
',': one_frame_backward,
'?': print_help,
'i': print_info,
'q': quit_app,
}
print "Press q to quit, ? to get help."
while True:
k=getch()
o=ord(k)
method=keybindings.get(k, None)
if method is not None:
method()
elif o >= 49 and o <= 57:
# Numeric value. Jump to a fraction of the movie.
v=0.1*(o-48)
player.set_position(v)
# Not wrapped methods:
# libvlc_get_version
# libvlc_exception_get_message
# libvlc_media_list_view_remove_at_index
# libvlc_media_list_view_insert_at_index
# libvlc_get_compiler
# mediacontrol_RGBPicture__free
# libvlc_free
# libvlc_event_type_name
# libvlc_get_vlc_instance
# libvlc_media_list_view_add_item
# libvlc_get_changeset
# libvlc_exception_init
# mediacontrol_exception_init
# mediacontrol_exception_create
# libvlc_new
# mediacontrol_exception_cleanup
# libvlc_exception_raise
# mediacontrol_new
# libvlc_media_list_view_index_of_item
# libvlc_exception_raised
# mediacontrol_StreamInformation__free
# mediacontrol_PlaylistSeq__free
# libvlc_exception_clear
# mediacontrol_exception_free
advene-1.0/lib/advene/player/gstreamer.py 0000644 0001752 0001752 00000073142 11672132267 020371 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
"""Gstreamer player interface.
Based on gst >= 0.10 API.
See http://pygstdocs.berlios.de/pygst-reference/index.html for API
Use appsink to get data out of a pipeline:
https://thomas.apestaart.org/thomas/trac/browser/tests/gst/crc/crc.py
"""
from gettext import gettext as _
import advene.core.config as config
from advene.util.helper import format_time
import os
import time
import gobject
gobject.threads_init()
import gtk
import sys
if config.data.os == 'win32':
#try to determine if gstreamer is already installed
fsenc = sys.getfilesystemencoding()
ppath = unicode(os.getenv('GST_PLUGIN_PATH', ""), fsenc)
if not ppath or not os.path.exists(ppath):
os.environ['GST_PLUGIN_PATH'] = os.path.join(config.data.path['advene'], 'gst', 'lib', 'gstreamer-0.10').encode(fsenc)
gstpath = unicode(os.getenv('PATH', ""), fsenc)
os.environ['PATH'] = os.pathsep.join( ( os.path.join(config.data.path['advene'], 'gst', 'bin'), gstpath) ).encode(fsenc)
else:
#even if gstpluginpath is defined, gst still may not be in path
gstpath = unicode(os.getenv('PATH', ""), fsenc)
h,t = os.path.split(ppath)
binpath,t = os.path.split(h)
os.environ['PATH'] = os.pathsep.join( (os.path.join( binpath, 'bin'), gstpath) ).encode(fsenc)
try:
import pygst
pygst.require('0.10')
import gst
from advene.util.snapshotter import Snapshotter
svgelement = None
# First try rsvgoverlay
if gst.element_factory_find('rsvgoverlay'):
svgelement = 'rsvgoverlay'
else:
# Not compiled. Try to fallback on the python version.
try:
import advene.util.svgoverlay
svgelement = 'pysvgoverlay'
except ImportError:
print "SVG overlay support not present"
print "SVG: Using %s element" % (svgelement or "None")
except ImportError:
gst=None
name="GStreamer video player"
def register(controller):
if gst is None:
return False
controller.register_player(Player)
return True
class StreamInformation:
def __init__(self):
self.streamstatus=None
self.url=""
self.position=0
self.length=0
class Snapshot:
def __init__(self, d=None):
if d is not None:
for k in ('width', 'height', 'data', 'type', 'date'):
try:
setattr(self, k, d[k])
except KeyError:
setattr(self, k, None)
class Position:
def __init__(self, value=0):
self.value=value
# See Player attributes below...
self.origin=0
self.key=2
def __str__(self):
return "Position " + str(self.value)
class PositionKeyNotSupported(Exception):
pass
class PositionOrigin(Exception):
pass
class InvalidPosition(Exception):
pass
class PlaylistException(Exception):
pass
class InternalException(Exception):
pass
# Placeholder
class Caption:
pass
class Player:
player_id='gstreamer'
player_capabilities=[ 'seek', 'pause', 'caption', 'frame-by-frame', 'async-snapshot', 'set-rate' ]
# Class attributes
AbsolutePosition=0
RelativePosition=1
ModuloPosition=2
ByteCount=0
SampleCount=1
MediaTime=2
# Status
PlayingStatus=0
PauseStatus=1
InitStatus=2
EndStatus=3
UndefinedStatus=4
PositionKeyNotSupported=Exception("Position key not supported")
PositionOriginNotSupported=Exception("Position origin not supported")
InvalidPosition=Exception("Invalid position")
PlaylistException=Exception("Playlist error")
InternalException=Exception("Internal player error")
def __init__(self):
self.xid = None
self.mute_volume=None
self.rate = 1.0
# fullscreen gtk.Window
self.fullscreen_window=None
# Fullscreen timestamp display - cache data
self.last_timestamp = 0
self.last_timestamp_update = 0
try:
self.snapshotter = Snapshotter(self.snapshot_taken, width=config.data.player['snapshot-width'])
except Exception, e:
self.log(u"Could not initialize snapshotter:" + unicode(e))
self.snapshotter = None
self.fullres_snapshotter = None
# This method has the following signature:
# self.fullres_snapshot_callback(snapshot=None, message=None)
# If snapshot is None, then there should be an explanation (string) in msg.
self.fullres_snapshot_callback = None
#self.snapshotter.start()
# This method should be set by caller:
self.snapshot_notify=None
self.build_pipeline()
self.caption=Caption()
self.caption.text=""
self.caption.begin=-1
self.caption.end=-1
self.overlay=Caption()
self.overlay.data=''
self.overlay.begin=-1
self.overlay.end=-1
self.videofile=None
self.status=Player.UndefinedStatus
self.current_position_value = 0
self.stream_duration = 0
self.relative_position=self.create_position(0,
origin=self.RelativePosition)
self.position_update()
def log (self, msg):
"""Display a message.
"""
print "gstreamer:", unicode(msg).encode('utf-8')
def build_pipeline(self):
sink='xvimagesink'
if config.data.player['vout'] == 'x11':
sink='ximagesink'
elif config.data.player['vout'] == 'gl':
sink='glimagesink'
if config.data.os == 'win32':
sink='directdrawsink'
self.player = gst.element_factory_make("playbin", "player")
self.video_sink = gst.Bin()
# TextOverlay does not seem to be present in win32 installer. Do without it.
try:
self.captioner=gst.element_factory_make('textoverlay', 'captioner')
# FIXME: move to config.data
self.captioner.props.font_desc='Sans 24'
#self.caption.props.text="Foobar"
except:
self.captioner=None
self.imageoverlay=None
if config.data.player['svg'] and svgelement:
try:
self.imageoverlay=gst.element_factory_make(svgelement, 'overlay')
self.imageoverlay.props.fit_to_frame = True
except:
pass
self.imagesink = gst.element_factory_make(sink, 'sink')
elements=[]
if self.captioner is not None:
elements.append(self.captioner)
if self.imageoverlay is not None:
elements.append(gst.element_factory_make('queue'))
elements.append(gst.element_factory_make('ffmpegcolorspace'))
elements.append(self.imageoverlay)
# Note: do not remove the (seemingly superfluous)
# ffmpegcolorspace here, else it blocks the pipeline for
# some unknown reason.
elements.append(gst.element_factory_make('ffmpegcolorspace'))
if sink == 'xvimagesink':
# Imagesink accepts both rgb/yuv and is able to do scaling itself.
elements.append( self.imagesink )
else:
csp=gst.element_factory_make('ffmpegcolorspace')
elements.extend( (csp, self.imagesink) )
self.video_sink.add(*elements)
if len(elements) >= 2:
gst.element_link_many(*elements)
self.log("gstreamer: using " + sink)
# Note: it is crucial to make ghostpad an attribute, so that
# it is not garbage-collected at the end of the build_pipeline
# method.
self._video_ghostpad = gst.GhostPad('sink', elements[0].get_pad('video_sink') or elements[0].get_pad('sink'))
# Idem for elements
self._video_elements = elements
self.video_sink.add_pad(self._video_ghostpad)
self.player.props.video_sink=self.video_sink
if gst.element_factory_find('scaletempo'):
# The scaletempo element is present. Use it.
self.audio_sink = gst.Bin()
elements = [
gst.element_factory_make('scaletempo'),
gst.element_factory_make('autoaudiosink'),
]
self.audio_sink.add(*elements)
if len(elements) >= 2:
gst.element_link_many(*elements)
self.player.props.audio_sink = self.audio_sink
# Keep a ref. on elements
self._audio_elements = elements
self._audio_ghostpad = gst.GhostPad('sink', elements[0].get_pad('audio_sink') or elements[0].get_pad('sink'))
self.audio_sink.add_pad(self._audio_ghostpad)
bus = self.player.get_bus()
bus.enable_sync_message_emission()
bus.connect('sync-message::element', self.on_sync_message)
def position2value(self, p):
"""Returns a position in ms.
"""
if isinstance(p, Position):
v=p.value
if p.key != self.MediaTime:
self.log("unsupported key " + p.key)
return 0
if p.origin != self.AbsolutePosition:
v += self.current_position()
else:
v=p
return long(v)
def current_status(self):
st=self.player.get_state()[1]
if st == gst.STATE_PLAYING:
return self.PlayingStatus
elif st == gst.STATE_PAUSED:
return self.PauseStatus
else:
return self.UndefinedStatus
def current_position(self):
"""Returns the current position in ms.
"""
try:
pos, format = self.player.query_position(gst.FORMAT_TIME)
except:
position = 0
else:
position = pos * 1.0 / gst.MSECOND
return position
def dvd_uri(self, title=None, chapter=None):
# FIXME: find the syntax to specify chapter
return "dvd://%s" % str(title)
def check_uri(self):
uri=self.player.get_property('uri')
if uri and gst.uri_is_valid(uri):
return True
else:
self.log(u"Invalid URI" + unicode(uri))
return False
def get_media_position(self, origin, key):
return self.current_position()
def set_media_position(self, position):
if not self.check_uri():
return
if self.current_status() == self.UndefinedStatus:
self.player.set_state(gst.STATE_PAUSED)
p = long(self.position2value(position) * gst.MSECOND)
event = gst.event_new_seek(self.rate, gst.FORMAT_TIME,
gst.SEEK_FLAG_FLUSH | gst.SEEK_FLAG_ACCURATE,
gst.SEEK_TYPE_SET, p,
gst.SEEK_TYPE_NONE, 0)
res = self.player.send_event(event)
if not res:
raise InternalException
def start(self, position=0):
if not self.check_uri():
return
if position != 0:
self.set_media_position(position)
self.player.set_state(gst.STATE_PLAYING)
def pause(self, position=0):
if not self.check_uri():
return
if self.status == self.PlayingStatus:
self.player.set_state(gst.STATE_PAUSED)
else:
self.player.set_state(gst.STATE_PLAYING)
def resume(self, position=0):
self.pause(position)
def stop(self, position=0):
if not self.check_uri():
return
self.player.set_state(gst.STATE_READY)
def exit(self):
self.player.set_state(gst.STATE_NULL)
def playlist_add_item(self, item):
self.videofile=item
if config.data.os == 'win32':
#item is a str, os.path needs to work with unicode obj to accept unicode path
item = os.path.abspath(unicode(item))
if os.path.exists(item):
item="file:///" + item
elif os.path.exists(item):
item="file://" + os.path.abspath(item)
self.player.set_property('uri', item)
if self.snapshotter:
self.snapshotter.set_uri(item)
if self.fullres_snapshotter:
self.fullres_snapshotter.set_uri(item)
def playlist_clear(self):
self.videofile=None
self.player.set_property('uri', '')
def playlist_get_list(self):
if self.videofile:
return [ self.videofile ]
else:
return [ ]
def fullres_snapshot_taken(self, buffer):
if self.fullres_snapshot_callback:
s=Snapshot( { 'data': buffer.data,
'type': 'PNG',
'date': buffer.timestamp / gst.MSECOND,
# Hardcoded size values. They are not used
# by the application, since they are
# encoded in the PNG file anyway.
'width': 160,
'height': 100 } )
self.fullres_snapshot_callback(snapshot=s)
self.fullres_snapshot_callback = None
def async_fullres_snapshot(self, position, callback):
"""Take full-resolution snapshots.
This method is not reentrant: as long as there is a call
pending, it is not available for another position.
"""
if self.fullres_snapshot_callback is not None:
callback(message=_("Cannot capture full-resolution snapshot, another capture is ongoing."))
return
if self.fullres_snapshotter is None:
# Initialise it.
self.fullres_snapshotter = Snapshotter(self.fullres_snapshot_taken)
self.fullres_snapshotter.set_uri(self.player.get_property('uri'))
self.fullres_snapshot_callback = callback
if not self.fullres_snapshotter.thread_running:
self.fullres_snapshotter.start()
self.fullres_snapshotter.enqueue(position)
def snapshot_taken(self, buffer):
if self.snapshot_notify:
s=Snapshot( { 'data': buffer.data,
'type': 'PNG',
'date': buffer.timestamp / gst.MSECOND,
# Hardcoded size values. They are not used
# by the application, since they are
# encoded in the PNG file anyway.
'width': 160,
'height': 100 } )
self.snapshot_notify(s)
def async_snapshot(self, position):
t = long(self.position2value(position))
if self.snapshotter:
if not self.snapshotter.thread_running:
self.snapshotter.start()
# We enqueue 3 timestamps: the original timestamp, its
# value minus 20ms (the async snapshotter goes to the
# specified position then takes the video buffer which may then
# be later) and its value aligned to a frame boundary
# (considering a 25f/s framerate).
for pos in sorted((t - 20, t / 25 * 25, t)):
self.snapshotter.enqueue(pos)
def snapshot(self, position):
if not self.check_uri():
return None
# Return None in all cases.
return None
def all_snapshots(self):
self.log("all_snapshots %s")
return [ None ]
def display_text (self, message, begin, end):
if not self.check_uri():
return
if message.startswith(' 100:
v = 100
elif v < 0:
v = 0
v = v * 4.0 / 100
self.player.set_property('volume', v)
# Helper methods
def create_position (self, value=0, key=None, origin=None):
"""Create a Position.
"""
if key is None:
key=self.MediaTime
if origin is None:
origin=self.AbsolutePosition
p=Position()
p.value = value
p.origin = origin
p.key = key
return p
def update_status (self, status=None, position=None):
"""Update the player status.
Defined status:
- C{start}
- C{pause}
- C{resume}
- C{stop}
- C{set}
If no status is given, it only updates the value of self.status
If C{position} is None, it will be considered as zero for the
"start" action, and as the current relative position for other
actions.
@param status: the new status
@type status: string
@param position: the position
@type position: long
"""
#print "gst - update_status ", status, str(position)
if position is None:
position=0
else:
position=self.position2value(position)
if status == "start" or status == "set":
self.position_update()
if status == "start":
if self.status == self.PauseStatus:
self.resume (position)
elif self.status != self.PlayingStatus:
self.start(position)
time.sleep(0.005)
# print "Before s_m_p", position
self.set_media_position(position)
# print "After s_m_p"
else:
if status == "pause":
self.position_update()
if self.status == self.PauseStatus:
self.resume (position)
else:
self.pause(position)
elif status == "resume":
self.resume (position)
elif status == "stop":
self.stop (position)
elif status == "" or status == None:
pass
else:
self.log("******* Error : unknown status %s in gstreamer player" % status)
self.position_update ()
def is_active(self):
return True
def check_player(self):
self.log("check player")
return True
def position_update(self):
s = self.get_stream_information ()
if s.position == 0:
# Try again once. timestamp sometimes goes through 0 when
# modifying the player position.
s = self.get_stream_information()
self.status = s.status
self.stream_duration = s.length
self.current_position_value = long(s.position)
if self.caption.text and (s.position < self.caption.begin
or s.position > self.caption.end):
self.display_text('', -1, -1)
if self.overlay.data and (s.position < self.overlay.begin
or s.position > self.overlay.end):
self.imageoverlay.props.data=None
self.overlay.begin=-1
self.overlay.end=-1
self.overlay.data=None
elif not self.overlay.data and self.imageoverlay is not None and self.is_fullscreen() and config.data.player.get('fullscreen-timestamp', False):
t = time.time()
# Update timestamp every half second
if t - self.last_timestamp_update > .5 and abs(s.position - self.last_timestamp) > 10:
self.imageoverlay.props.data = '''
%s
''' % format_time(s.position)
self.last_timestamp = s.position
self.last_timestamp_update = t
def reparent(self, xid):
# See https://bugzilla.gnome.org/show_bug.cgi?id=599885
#gtk.gdk.threads_enter()
if xid:
self.log("Reparent " + hex(xid))
gtk.gdk.display_get_default().sync()
self.imagesink.set_xwindow_id(xid)
self.imagesink.set_property('force-aspect-ratio', True)
self.imagesink.expose()
#gtk.gdk.threads_leave()
def set_visual(self, xid):
if not xid:
return True
self.xid = xid
self.reparent(xid)
return True
def set_widget(self, widget):
self.set_visual( widget.get_id() )
#self.set_visual( None )
def restart_player(self):
# FIXME: destroy the previous player
self.player.set_state(gst.STATE_READY)
# Rebuild the pipeline
self.build_pipeline()
if self.videofile is not None:
self.playlist_add_item(self.videofile)
self.position_update()
return True
def on_sync_message(self, bus, message):
if message.structure is None:
return True
if message.structure.get_name() == 'prepare-xwindow-id':
self.reparent(self.xid)
return True
def sound_mute(self):
if self.mute_volume is None:
self.mute_volume=self.sound_get_volume()
self.sound_set_volume(0)
return
def sound_unmute(self):
if self.mute_volume is not None:
self.sound_set_volume(self.mute_volume)
self.mute_volume=None
return
def sound_is_muted(self):
return (self.mute_volume is not None)
def set_rate(self, rate=1.0):
if not self.check_uri():
return
self.rate = rate
try:
p = self.player.query_position(gst.FORMAT_TIME)[0]
except gst.QueryError:
self.log("Error in set_rate (query position)")
return
event = gst.event_new_seek(self.rate, gst.FORMAT_TIME,
gst.SEEK_FLAG_FLUSH,
gst.SEEK_TYPE_SET, long(p),
gst.SEEK_TYPE_NONE, 0)
if event:
res = self.player.send_event(event)
if not res:
self.log("Could not set rate")
else:
self.log("Cannot build set_rate event")
def get_rate(self):
return self.rate
def disp(self, e, indent=" "):
l=[str(e)]
if hasattr(e, 'elements'):
i=indent+" "
l.extend( [ self.disp(c, i) for c in e.elements() ])
return ("\n"+indent).join(l)
def is_fullscreen(self):
return self.fullscreen_window and self.fullscreen_window.is_active()
def fullscreen(self, connect=None):
def keypress(widget, event):
if event.keyval == gtk.keysyms.Escape:
self.unfullscreen()
return True
return False
def buttonpress(widget, event):
if event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS:
self.unfullscreen()
return True
return False
if self.fullscreen_window is None:
self.fullscreen_window=gtk.Window()
self.fullscreen_window.add_events(gtk.gdk.BUTTON_PRESS_MASK |
gtk.gdk.BUTTON_RELEASE_MASK |
gtk.gdk.KEY_PRESS_MASK |
gtk.gdk.KEY_RELEASE_MASK |
gtk.gdk.SCROLL_MASK)
self.fullscreen_window.connect('key-press-event', keypress)
self.fullscreen_window.connect('button-press-event', buttonpress)
self.fullscreen_window.connect('destroy', self.unfullscreen)
if connect is not None:
connect(self.fullscreen_window)
style=self.fullscreen_window.get_style().copy()
black=gtk.gdk.color_parse('black')
for state in (gtk.STATE_ACTIVE, gtk.STATE_NORMAL,
gtk.STATE_SELECTED, gtk.STATE_INSENSITIVE,
gtk.STATE_PRELIGHT):
style.bg[state]=black
style.base[state]=black
self.fullscreen_window.set_style(style)
if config.data.os == 'darwin':
# Get geometry of the first monitor
r = gtk.gdk.screen_get_default().get_monitor_geometry(0)
self.fullscreen_window.set_decorated(False)
self.fullscreen_window.set_size_request(r.width, r.height)
#self.fullscreen_window.move(r.x, r.y)
self.fullscreen_window.move(0, 0)
self.fullscreen_window.show()
else:
self.fullscreen_window.show()
self.fullscreen_window.window.fullscreen()
self.fullscreen_window.grab_focus()
if config.data.os == 'win32':
self.reparent(self.fullscreen_window.window.handle)
else:
self.reparent(self.fullscreen_window.window.xid)
def unfullscreen(self, *p):
self.reparent(self.xid)
if not self.overlay.data and self.imageoverlay:
# Reset imageoverlay data in any case
self.imageoverlay.props.data = None
if self.fullscreen_window.window:
self.fullscreen_window.hide()
else:
# It has been destroyed
self.fullscreen_window = None
return True
# relpath, dump_bin and dump_element implementation based on Daniel Lenski
# posted on gst-dev mailing list on 20070913
def relpath(self, p1, p2):
sep = os.path.sep
# get common prefix (up to a slash)
common = os.path.commonprefix((p1, p2))
common = common[:common.rfind(sep)]
# remove common prefix
p1 = p1[len(common)+1:]
p2 = p2[len(common)+1:]
# number of seps in p1 is # of ..'s needed
return "../" * p1.count(sep) + p2
def dump_bin(self, bin, depth=0, recurse=-1, showcaps=True):
return [ l for e in reversed(list(bin)) for l in self.dump_element(e, depth, recurse - 1) ]
def dump_element(self, e, depth=0, recurse=-1, showcaps=True):
ret=[]
indentstr = depth * 8 * ' '
# print element path and factory
path = e.get_path_string() + (isinstance(e, gst.Bin) and '/' or '')
factory = e.get_factory()
if factory is not None:
ret.append( '%s%s (%s)' % (indentstr, path, factory.get_name()) )
else:
ret.append( '%s%s (No factory)' % (indentstr, path) )
# print info about each pad
for p in e.pads():
name = p.get_name()
# negotiated capabilities
caps = p.get_negotiated_caps()
if caps: capsname = caps[0].get_name()
elif showcaps: capsname = '; '.join(s.to_string() for s in set(p.get_caps()))
else: capsname = None
# flags
flags = []
if not p.is_active(): flags.append('INACTIVE')
if p.is_blocked(): flags.append('BLOCKED')
# direction
direc = (p.get_direction() is gst.PAD_SRC) and "=>" or "<="
# peer
peer = p.get_peer()
if peer: peerpath = self.relpath(path, peer.get_path_string())
else: peerpath = None
# ghost target
if isinstance(p, gst.GhostPad):
target = p.get_target()
if target: ghostpath = target.get_path_string()
else: ghostpath = None
else:
ghostpath = None
line=[ indentstr, " " ]
if flags: line.append( ','.join(flags) )
line.append(".%s" % name)
if capsname: line.append( '[%s]' % capsname )
if ghostpath: line.append( "ghosts %s" % self.relpath(path, ghostpath) )
line.append( "%s %s" % (direc, peerpath) )
#if peerpath and peerpath.find('proxy')!=-1: print peer
ret.append( ''.join(line) )
if recurse and isinstance(e, gst.Bin):
ret.extend( self.dump_bin(e, depth+1, recurse) )
return ret
def str_element(self, element):
return "\n".join(self.dump_element(element))
advene-1.0/lib/advene/player/dummy.py 0000644 0001752 0001752 00000021746 11475540721 017535 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
"""Dummy player interface.
This dummy player can be used to test the Advene GUI without any player dependency.
It also presents the API that should be implemented by alternative players.
"""
from time import time
name="Dummy video player"
def register(controller):
controller.register_player(Player)
return True
class StreamInformation:
def __init__(self):
self.streamstatus=None
self.url=""
self.position=0
self.length=0
class Position:
def __init__(self, value=0):
self.value=value
# See Player attributes below...
self.origin=0
self.key=2
class PositionKeyNotSupported(Exception):
pass
class PositionOrigin(Exception):
pass
class InvalidPosition(Exception):
pass
class PlaylistException(Exception):
pass
class InternalException(Exception):
pass
class Player:
player_id='dummy'
player_capabilities=[ 'seek', 'pause', 'caption', 'svg', 'frame-by-frame' ]
# Class attributes
AbsolutePosition=0
RelativePosition=1
ModuloPosition=2
ByteCount=0
SampleCount=1
MediaTime=2
# Status
PlayingStatus=0
PauseStatus=1
InitStatus=2
EndStatus=3
UndefinedStatus=4
PositionKeyNotSupported=Exception()
PositionOriginNotSupported=Exception()
InvalidPosition=Exception()
PlaylistException=Exception()
InternalException=Exception()
def __init__(self):
self.playlist=[]
self.relative_position=0
self.status=Player.UndefinedStatus
self.basetime=None
self.pausetime=None
self.volume=12
self.mute_volume=None
self.stream_duration = 0
self.position_update()
def position2value(self, p):
if isinstance(p, Position):
v=p.value
if p.key != self.MediaTime:
self.log("unsupported key ", p.key)
return 0
if p.origin == self.AbsolutePosition:
v=p.value
else:
v=self.current_position() + p.value
else:
v=long(p)
return v
def current_position(self):
if self.pausetime is not None:
return self.pausetime
elif self.basetime is None:
return 0
else:
return time() * 1000 - self.basetime
def dvd_uri(self, title=None, chapter=None):
return "dvd@%s:%s" % (str(title),
str(chapter))
def log(self, *m):
print "dummy plugin:", " ".join([str(i) for i in m])
def get_media_position(self, origin=None, key=None):
self.log("get_media_position")
return self.current_position()
def set_media_position(self, position=0):
position = self.position2value(position)
self.log("set_media_position %s" % str(position))
self.basetime = time() * 1000 - position
if self.pausetime is not None:
self.pausetime = time() * 1000 - self.basetime
return
def start(self, position=0):
self.log("start %s" % str(position))
self.status=Player.PlayingStatus
self.basetime=time() * 1000 - position
self.pausetime=None
def pause(self, position=0):
self.log("pause %s" % str(position))
if self.status == Player.PlayingStatus:
self.pausetime=time() * 1000 - self.basetime
self.status=Player.PauseStatus
else:
self.status=Player.PlayingStatus
self.basetime=time() * 1000 - (self.pausetime or 0)
self.pausetime=None
def resume(self, position=0):
self.log("resume %s" % str(position))
if self.status == Player.PlayingStatus:
self.pausetime=time() * 1000 - self.basetime
self.status=Player.PauseStatus
else:
self.status=Player.PlayingStatus
self.basetime=time() * 1000 - (self.pausetime or 0)
self.pausetime=None
def stop(self, position=0):
self.log("stop %s" % str(position))
self.status=Player.UndefinedStatus
self.basetime=None
self.pausetime=None
def exit(self):
self.log("exit")
def playlist_add_item(self, item):
self.playlist.append(item)
# Simulate a 30 minutes movie
self.stream_duration = 30 * 60000
def playlist_clear(self):
del self.playlist[:]
self.stream_duration = 0
def playlist_get_list(self):
return self.playlist[:]
def snapshot(self, position):
self.log("snapshot %s" % str(position))
return None
def all_snapshots(self):
self.log("all_snapshots")
return [ None ]
def display_text (self, message, begin, end):
self.log("display_text %s" % str(message))
def get_stream_information(self):
s=StreamInformation()
s.url=''
if self.playlist:
s.url=self.playlist[0]
s.length=self.stream_duration
if self.pausetime:
s.position=self.pausetime
elif self.basetime:
s.position=time() * 1000 - self.basetime
else:
s.position=0
s.streamstatus=self.status
return s
def sound_get_volume(self):
return self.volume
def sound_set_volume(self, v):
self.log("sound_set_volume %s" % str(v))
self.volume = v
# Helper methods
def create_position (self, value=0, key=None, origin=None):
"""Create a Position.
"""
if key is None:
key=self.MediaTime
if origin is None:
origin=self.AbsolutePosition
p=Position()
p.value = value
p.origin = origin
p.key = key
return p
def update_status (self, status=None, position=None):
"""Update the player status.
Defined status:
- C{start}
- C{pause}
- C{resume}
- C{stop}
- C{set}
If no status is given, it only updates the value of self.status
If C{position} is None, it will be considered as zero for the
"start" action, and as the current relative position for other
actions.
@param status: the new status
@type status: string
@param position: the position
@type position: long
"""
self.log("update_status %s" % status)
if position is None:
position=0
else:
position=self.position2value(position)
if status == "start" or status == "set":
self.position_update()
if self.status in (self.EndStatus, self.UndefinedStatus):
self.start(position)
else:
self.set_media_position(position)
else:
if status == "pause":
self.position_update()
if self.status == self.PauseStatus:
self.resume (position)
else:
self.pause(position)
elif status == "resume":
self.resume (position)
elif status == "stop":
self.stop (position)
elif status == "" or status == None:
pass
else:
self.log("******* Error : unknown status %s")
self.position_update ()
def is_active(self):
return True
def check_player(self):
self.log("check player")
return True
def position_update(self):
s = self.get_stream_information ()
self.status = s.streamstatus
self.stream_duration = s.length
self.current_position_value = s.position
def set_visual(self, xid):
"""Set the window id for the video output.
It is widget.window.xid on X, widget.window.handle on Win32.
"""
return True
def restart_player(self):
self.log("restart player")
return True
def sound_mute(self):
if self.mute_volume is None:
self.mute_volume=self.sound_get_volume()
self.sound_set_volume(0)
return
def sound_unmute(self):
if self.mute_volume is not None:
self.sound_set_volume(self.mute_volume)
self.mute_volume=None
return
def sound_is_muted(self):
return (self.mute_volume is not None)
advene-1.0/lib/advene/__init__.py 0000644 0001752 0001752 00000001453 11341717673 016642 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
advene-1.0/lib/advene/plugins/ 0000755 0001752 0001752 00000000000 11672132263 016200 5 ustar oaubert oaubert advene-1.0/lib/advene/plugins/featuredetect.py 0000644 0001752 0001752 00000017137 11672132263 021407 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
name="Feature detection importer"
from gettext import gettext as _
import os
import sys
import operator
try:
import cv
except ImportError:
cv = None
import advene.core.config as config
from advene.util.importer import GenericImporter
import advene.util.helper as helper
def register(controller=None):
if cv:
controller.register_importer(FeatureDetectImporter)
return True
class FeatureDetectImporter(GenericImporter):
name = _("Feature detection (face...)")
def __init__(self, *p, **kw):
super(FeatureDetectImporter, self).__init__(*p, **kw)
self.threshold = 10
self.scale = 2
classifiers = [ n.replace('.xml', '') for n in os.listdir(config.data.advenefile('haars')) ]
self.classifier = classifiers[0]
# Detect that a shape has moved
self.motion_threshold = 5
self.optionparser.add_option("-t", "--threshold",
action="store", type="int", dest="threshold", default=self.threshold,
help=_("Sensitivity level."))
self.optionparser.add_option("-s", "--scale",
action="store", type="int", dest="scale", default=self.scale,
help=_("Scale. Original image size will be divided by this factor, in order to speed up detection."))
self.optionparser.add_option("-c", "--classifier",
action="store", type="choice", dest="classifier", choices=classifiers, default=self.classifier,
help=_("Classifier"))
def can_handle(fname):
"""Return a score between 0 and 100.
100 is for the best match (specific extension), 0 is for no match at all.
"""
ext = os.path.splitext(fname)[1]
if ext in config.data.video_extensions:
return 80
return 0
can_handle=staticmethod(can_handle)
def process_file(self, filename):
at = self.ensure_new_type('feature', title=_("Feature %s") % self.classifier)
at.mimetype = 'image/svg+xml'
at.setMetaData(config.data.namespace_prefix['dc'], "description", _("Detected %s") % self.classifier)
self.progress(0, _("Detection started"))
video = cv.CreateFileCapture(unicode(filename).encode(sys.getfilesystemencoding()))
if not video:
raise "Cannot read video file:"
self.convert(self.iterator(video))
return self.package
def iterator(self, video):
def svg_rect(x, y , w, h):
return
# Take the first frame to get width/height
pos = cv.GetCaptureProperty(video, cv.CV_CAP_PROP_POS_MSEC)
frame = cv.QueryFrame(video)
width, height = cv.GetSize(frame)
scaled_width, scaled_height = int(width / self.scale), int(height / self.scale)
print width, height, scaled_width, scaled_height
# create storage for grayscale version
largegrayscale = cv.CreateImage( (width, height), 8, 1)
grayscale = cv.CreateImage( (scaled_width, scaled_height), 8, 1)
# create storage
storage = cv.CreateMemStorage(128)
cascade = cv.Load(config.data.advenefile( ('haars', self.classifier + '.xml') ))
count = 0
svg_template = """%%s """ % locals()
def objects2svg(objs, threshold=-1):
"""Convert a object-list into SVG.
Only objects above threshold will be generated.
"""
return svg_template % "\n".join("""
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
# Anvil importer.
name="Anvil importer"
from gettext import gettext as _
import advene.core.config as config
from advene.util.importer import GenericImporter
import xml.etree.ElementTree as ET
def register(controller=None):
controller.register_importer(AnvilImporter)
return True
class AnvilImporter(GenericImporter):
name = _("Anvil importer")
def can_handle(fname):
"""Return a score between 0 and 100.
100 is for the best match (specific extension), 0 is for no match at all.
"""
if fname.endswith('.anvil'):
return 100
elif fname.endswith('.xml'):
return 30
return 0
can_handle=staticmethod(can_handle)
def process_file(self, filename):
tree=ET.parse(filename)
root=tree.getroot()
p, at=self.init_package(filename=filename,
schemaid='anvil', annotationtypeid=None)
video=root.find('head/video')
if video is not None:
mediafile=video.attrib['src']
p.setMetaData(config.data.namespace, 'mediafile', mediafile)
self.convert(self.iterator(root))
self.progress(1.0)
return self.package
def iterator(self, root):
schema=self.package.get_element_by_id('anvil')
if root.tag != 'annotation':
print "Invalid Anvil file format: ", root.tag
return
progress=0.01
self.progress(progress)
l=root.findall('.//track')
type_incr=0.98/len(l)
for track in l:
at=self.create_annotation_type (schema, track.attrib['name'])
self.progress(value=progress, label="Converting " + at.id)
attribnames=set()
elements=track.findall('.//el')
el_incr=type_incr / len(elements)
for el in elements:
progress += el_incr
self.progress(progress)
content="\n".join( [ "%s=%s" % (a.attrib['name'], a.text)
for a in el.findall('attribute') ] )
attribnames.update([ a.attrib['name'] for a in el.findall('attribute') ])
yield {
'type': at,
'content': content,
'begin': long(float(el.attrib['start']) * 1000),
'end': long(float(el.attrib['end']) * 1000),
}
if len(attribnames) == 1:
n=list(attribnames)[0]
# Only 1 attribute name. Define an appropriate
# representation for the type.
at.setMetaData(config.data.namespace, 'representation', 'here/content/parsed/' + n)
at.mimetype='application/x-advene-structured'
self.controller.notify('AnnotationTypeEditEnd', annotationtype=at)
self.progress(1.0)
if __name__ == "__main__":
import sys
if len(sys.argv) < 3:
print "Should provide a file name and a package name"
sys.exit(1)
fname=sys.argv[1]
pname=sys.argv[2]
i = AnvilImporter()
# FIXME: i.process_options()
i.process_options(sys.argv[1:])
# (for .sub conversion for instance, --fps, --offset)
print "Converting %s to %s using %s" % (fname, pname, i.name)
p=i.process_file(fname)
p.save(pname)
print i.statistics_formatted()
advene-1.0/lib/advene/plugins/ted.py 0000644 0001752 0001752 00000012355 11672132263 017334 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2009 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
name="TED transcription importer"
from gettext import gettext as _
import re
import urllib
try:
# json is standard in python 2.6
import json
except ImportError:
import simplejson as json
from advene.util.importer import GenericImporter
def register(controller=None):
controller.register_importer(TEDImporter)
return True
class TEDImporter(GenericImporter):
name = _("TED importer")
@staticmethod
def can_handle(fname):
"""Return a score between 0 and 100.
100 is for the best match (specific extension), 0 is for no match at all.
"""
if fname.startswith('http://www.ted.com'):
return 100
elif fname.endswith('.html'):
return 60
return 0
def process_file(self, filename):
self.progress(0.1, "Fetching " + filename)
if filename.startswith('http://www.ted.com'):
filename=filename.strip('#/')
f=urllib.urlopen(filename)
else:
f=open(filename, 'r')
data='\n'.join(f.readlines())
f.close()
p, at=self.init_package(filename=filename, schemaid='ted')
if self.package is None:
self.package=p
offset=re.findall('introDuration\s*:\s*(\d+)', data)
if offset:
offset=long(offset[0])
else:
offset=0
m = re.findall('/talks/subtitles/id/(\d+)', data, re.MULTILINE)
if m:
ident=m[0]
else:
self.log("Cannot find talk id")
ident=None
podcast=re.findall('(itpc://[^"]+)', data, re.MULTILINE)
if podcast:
podcast=podcast[0]
self.progress(0.2, "Fetching podcast information")
podcast=urllib.urlopen(podcast.replace('itpc:', 'http:'))
data=podcast.read()
podcast.close()
title=re.findall('(.+?) ', data)
if title:
self.package.title=title[0]
moviepath=re.findall('(.+?)', data)
if title:
self.package.title=title[0]
self.convert(self.html_iterator(data, offset))
self.progress(1.0)
return self.package
def html_iterator(self, data, offset):
at=self.create_annotation_type(self.package.get_element_by_id('ted'), 'transcription')
start=None
text=None
yield {
'type': at,
'content': "Introduction",
'begin': 0,
'end': offset,
}
for timestamp, buf in re.findall('seekVideo.(\d+).+?>(.+?)', data):
t=long(timestamp) + offset
if start is not None:
yield {
'type': at,
'content': text,
'begin': start,
'end': t,
}
start=t
text=buf
# Last item
if start is not None:
yield {
'content': text,
'begin': start,
'end': start + 2000, # FIXME: find out duration
}
def json_iterator(self, ident, offset=0):
urlbase='http://www.ted.com/talks/subtitles/id/%s' % ident
for lang in ('eng_en', 'fre_fr', ):
self.progress(0.1, "Converting %s subtitles" % lang)
at=self.create_annotation_type(self.package.get_element_by_id('ted'), lang)
url=urlbase+'/lang/'+lang
f=urllib.urlopen(url)
data=f.read()
f.close()
data=json.loads(data)
if not 'captions' in data:
# Language not present
continue
step=1.0 / len(data['captions'])
prg=0.1
yield {
'type': at,
'content': "Introduction",
'begin': 0,
'end': offset,
}
for d in data['captions']:
self.progress(prg)
prg += step
yield {
'type': at,
'content': d['content'],
'begin': d['startTime'] + offset,
'duration': d['duration'],
}
advene-1.0/lib/advene/plugins/annotationgraph.py 0000644 0001752 0001752 00000011503 11642631324 021745 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
# AnnotationGraph importer.
name="AnnotationGraph importer"
from gettext import gettext as _
import advene.core.config as config
from advene.util.importer import GenericImporter
import xml.etree.ElementTree as ET
def register(controller=None):
controller.register_importer(AnnotationGraphImporter)
return True
XLINKURI='http://www.w3.org/1999/xlink'
AGURI='http://www.ldc.upenn.edu/atlas/ag/'
def tag(n):
return ET.QName(AGURI, n)
class AnnotationGraphImporter(GenericImporter):
name = _("AnnotationGraph importer")
def can_handle(fname):
"""Return a score between 0 and 100.
100 is for the best match (specific extension), 0 is for no match at all.
"""
if fname.endswith('.ag'):
return 100
elif fname.endswith('.xml'):
return 30
return 0
can_handle=staticmethod(can_handle)
def process_file(self, filename, dest=None):
tree=ET.parse(filename)
root=tree.getroot()
p, at=self.init_package(filename=dest,
schemaid='ag', annotationtypeid=None)
self.package=p
video=root.find('%s/%s' % (tag('Timeline'), tag('Signal')))
if video is not None:
mediafile=video.attrib[ET.QName(XLINKURI, 'href')]
p.setMetaData(config.data.namespace, 'mediafile', mediafile)
self.convert(self.iterator(root))
self.progress(1.0)
return self.package
def iterator(self, root):
schema=self.package.get_element_by_id('ag')
if root.tag != tag('AGSet'):
print "Invalid AnnotationGraph file format: ", root.tag
return
# Import anchors
self.anchors={}
for anchor in root.findall('%s/%s' % (tag('AG'), tag('Anchor'))):
# FIXME: in multisignal version, use the appropriate signal
if anchor.attrib['unit'] != 'milliseconds':
print "Unhandled anchor unit (", anchor.attrib['unit'], ") Positioning will be wrong."
self.anchors[anchor.attrib['id']]=long(anchor.attrib['offset'])
ats={}
attribs={}
progress=0.01
self.progress(progress)
l=root.findall('%s/%s' % (tag('AG'), tag('Annotation')))
incr=0.98/len(l)
for an in l:
progress += incr
self.progress(progress)
t=an.attrib['type']
if not t in ats:
ats[t]=self.create_annotation_type (schema, t)
at=ats[t]
attribnames=attribs.setdefault(an.attrib['type'], set())
content="\n".join( [ "%s=%s" % (f.attrib['name'], f.text)
for f in an.findall(str(tag('Feature'))) ] )
attribnames.update([ f.attrib['name'] for f in an.findall(tag('Feature')) ])
yield {
'id': an.attrib['id'],
'type': at,
'content': content,
'begin': self.anchors[an.attrib['start']],
'end': self.anchors[an.attrib['end']],
}
for typename, atnames in attribs.iteritems():
if len(atnames) == 1:
n=list(atnames)[0]
# Only 1 attribute name. Define an appropriate
# representation for the type.
at=ats[typename]
at.setMetaData(config.data.namespace, 'representation', 'here/content/parsed/' + n)
at.mimetype='application/x-advene-structured'
self.controller.notify('AnnotationTypeEditEnd', annotationtype=at)
self.progress(1.0)
if __name__ == "__main__":
import sys
if len(sys.argv) < 3:
print "Should provide a file name and a package name"
sys.exit(1)
fname=sys.argv[1]
pname=sys.argv[2]
i = AnnotationGraphImporter()
# FIXME: i.process_options()
i.process_options(sys.argv[1:])
# (for .sub conversion for instance, --fps, --offset)
print "Converting %s to %s using %s" % (fname, pname, i.name)
p=i.process_file(fname)
p.save(pname)
print i.statistics_formatted()
advene-1.0/lib/advene/plugins/goodshotdetector.py 0000644 0001752 0001752 00000023570 11672132263 022141 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
from __future__ import division
name="Shot detection importer"
from gettext import gettext as _
import os
import sys
try:
# Needed for pimpy component
import numpy
import opencv.cv as cv
import opencv.highgui as hg
except ImportError:
numpy = cv = hg = None
import advene.core.config as config
from advene.util.importer import GenericImporter
def register(controller=None):
if numpy and cv and hg:
controller.register_importer(DelakisShotDetectImporter)
return True
class DelakisShotDetectImporter(GenericImporter):
name = _("Shot detection (Delakis version)")
profiles = {
'default': { 'ALPHA': 2.6, 'BETA': 0.05 },
'safe': { 'ALPHA': 2.9, 'BETA': 0.06 },
'aggressive': { 'ALPHA': 1.7, 'BETA': 0.05 },
}
def __init__(self, *p, **kw):
super(DelakisShotDetectImporter, self).__init__(*p, **kw)
self.cache_histogram = False
self.profile = 'default'
self.optionparser.add_option("-c", "--cache-histogram",
action="store_true", dest="cache_histogram", default=self.cache_histogram,
help=_("Cache histogram alongside video files."))
self.optionparser.add_option("-p", "--profile",
action="store", type="choice", dest="profile", choices=self.profiles.keys(), default=self.profile,
help=_("Parameter profile: safe will detect less cuts, aggressive will detect more cuts (but more false ones too). default is a compromise."))
def can_handle(fname):
"""Return a score between 0 and 100.
100 is for the best match (specific extension), 0 is for no match at all.
"""
ext = os.path.splitext(fname)[1]
if ext in config.data.video_extensions:
return 80
return 0
can_handle=staticmethod(can_handle)
def process_file(self, filename):
at = self.ensure_new_type('shot', title=_("Shot (%s profile)") % self.profile)
at.setMetaData(config.data.namespace_prefix['dc'], "description", _("Detected shots"))
#Compute or load histogram
histofile = filename + '-histogram.npy'
if os.path.exists(histofile):
self.progress(0, _("Loading histogram"))
histos = numpy.load(histofile)
# FIXME: how to cache FPS ?
fps = 25.0
else :
he = HistogramExtractor()
print "Processing ", filename
histos, fps = he.process(filename, self.progress)
if self.cache_histogram:
try:
numpy.save(histofile, histos)
except Exception, e:
self.controller.log("Cannot save histogram: %s" % e.message)
sd = ShotDetector()
for k, v in self.profiles[self.profile].iteritems():
setattr(sd, k, v)
#Detect cut and dissolve
self.convert(sd.process(histos, 1000 / fps))
return self.package
# Code adapted from pimpy: http://pim.gforge.inria.fr/pimpy/
NB_CHANNELS = 1
NB_BINS = 255
K=10
T=70
MEAN_WINDOW = 3
class ShotDetector:
"""
ShotDetector inspired by :
@phdthesis{DelakisPhd,
author = {Delakis, Manolis},
school = {Universite de Rennes 1, France},
title = {Multimodal Tennis Video Structure Analysis with Segment Models},
month = {October},
year = {2006},
url = {ftp://ftp.irisa.fr/techreports/theses/2006/delakis.pdf }
}
"""
def __init__(self, progress=None):
if progress is None:
progress = self.dummy_progress
self.progress = progress
self.ALPHA = 1.8
self.BETA = 0.10
self.MOTION_THRESHOLD = 0.15
self.SHOT_THRESHOLD = 0.15
self.HIGH_CUT_THRESHOLD = 0.8
self.DISS_THRESHOLD = 0.4
self.DISS_START_THRESHOLD = 0.16
self.DISS_END_THRESHOLD = 0.26
self.DISS_MIN_FRAMES = 3
def dummy_progress(self, prg, label):
pass
def process(self, histos, mspf=40):
print "MSPF", mspf
self.progress(.1, _("Computing hdiff"))
nbpixel = numpy.sum(histos[0])
#compute various histogram variations
hdiff = (numpy.abs(histos[:-1] - histos[1:])) / 2
hdiffsumchannel = numpy.sum(hdiff, axis=1)
histo_dist = hdiffsumchannel / nbpixel / NB_CHANNELS
self.progress(.2, _("Detecting cuts"))
#detect hard cut
cuts = numpy.flatnonzero( histo_dist >= self.HIGH_CUT_THRESHOLD )
#detect low cut
for f in numpy.flatnonzero(
(histo_dist < self.HIGH_CUT_THRESHOLD) &
(histo_dist >= self.SHOT_THRESHOLD)
):
if self.__cut_detection(f, histo_dist):
cuts = numpy.append(cuts, f)
cuts.sort()
n = 1
yield {
'begin': 0,
'end': cuts[0] * mspf,
'content': str(n),
}
for b, e in zip(cuts[:-1], cuts[1:]):
n += 1
yield {
'begin': b * mspf,
'end': e * mspf,
'content': str(n)
}
self.progress(.3, _("Detecting dissolves"))
#detect dissolve
hcumul = self.__histo_cumul(histos)
hcumul = self.__filter_by_cut(cuts, hcumul)
hpixelwise = self.__histo_pixelwise(hdiff)
hpixelwise = hpixelwise / nbpixel / 100
for diss in self.__detect_dissolve(hcumul, hpixelwise):
yield {
'begin': diss[0] * mspf,
'end': diss[1] * mspf,
'content': 'grad',
}
def __detect_dissolve(self, hcumul, hpixelwise):
motion_frames = hpixelwise > self.MOTION_THRESHOLD
start = end = -1
for f in numpy.flatnonzero(hcumul > self.DISS_THRESHOLD):
#new frame not in current dissolve, record dissolve
if start > 0 and f > end:
motion = numpy.sum(motion_frames[range(start,end)])
if not motion and end - start > self.DISS_MIN_FRAMES:
yield (start,end)
start = end = -1
if start < 0 :
start = end = f
#find lower bound
while start > 0 and hcumul[start] > self.DISS_START_THRESHOLD:
start -= 1
#find upper bound
while end+1 < len(hcumul) and hcumul[end+1] > self.DISS_END_THRESHOLD :
end += 1
#add the last dissolve
if start > 0 and end > 0 :
motion = numpy.sum(motion_frames[range(start,end)])
if not motion and end - start > self.DISS_MIN_FRAMES:
yield (start,end)
def __histo_pixelwise(self,hdiff):
r = []
for h in hdiff:
s = 0
for i in range(T, NB_BINS):
s += (h[i] * (i-T-1))
r.append(s)
return numpy.array(r)
def __histo_cumul(self, histos):
nbpix = numpy.sum(histos[0])
r = []
for i in range(1, len(histos)):
h = (histos[i] + histos[i-1]) / 2
c = 0
for k in range(1, K):
if i - k < 0 :
break
c += numpy.sum(numpy.abs(h - histos[i - k])) / nbpix
r.append(c / K)
return numpy.array(r)
def __filter_by_cut(self, cuts, histo_cumul):
for c in cuts:
for i in range(K):
try :
histo_cumul[c + i] = histo_cumul[c + i]/(K - i)
except IndexError:
break
return histo_cumul
def __cut_detection(self, f, histo_dist):
d = histo_dist[f]
left_diff = histo_dist[f - 1 - MEAN_WINDOW : f - 1] + self.BETA
right_diff = histo_dist[f + 1 : f + 1 + MEAN_WINDOW] + self.BETA
mean_left = numpy.mean(left_diff)
mean_rigth = numpy.mean(right_diff)
mean_local = (mean_left + mean_rigth) / 2
adapt_threshold = self.ALPHA * mean_local - self.BETA
return d >= adapt_threshold
class HistogramExtractor:
def process(self, videofile, progress):
progress(0, _("Extracting histogram"))
video = hg.cvCreateFileCapture(unicode(videofile).encode(sys.getfilesystemencoding()))
if not video:
raise Exception("Could not open video file")
histo = cv.cvCreateHist([256],cv.CV_HIST_ARRAY,[[0,256]], 1)
frame = hg.cvQueryFrame(video)
frame_gray = cv.cvCreateImage(cv.cvGetSize(frame), frame.depth, 1);
hists = []
nbframes = 0
fps = hg.cvGetCaptureProperty(video, hg.CV_CAP_PROP_FPS)
while frame :
if not progress(hg.cvGetCaptureProperty(video, hg.CV_CAP_PROP_POS_AVI_RATIO)):
break
hg.cvConvertImage(frame,frame_gray)
cv.cvCalcHist(frame_gray,histo,0,None)
h = [cv.cvGetReal1D(histo.bins,i) for i in range(255) ]
h = numpy.array(h,dtype='int32')
hists.append(h)
frame = hg.cvQueryFrame(video)
nbframes += 1
hists = numpy.array(hists)
return hists.reshape(nbframes, -1), fps
advene-1.0/lib/advene/plugins/montagerenderer.py 0000644 0001752 0001752 00000016672 11672132263 021747 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
"""Montage export module.
"""
import os
import sys
try:
import gst
except ImportError:
gst = None
from gettext import gettext as _
name = 'montagerenderer'
def register(controller):
if ( gst is not None
and gst.element_factory_find('gnlcomposition')
and gst.element_factory_find('gnlfilesource')
and gst.element_factory_find('theoraenc')
and gst.element_factory_find('vorbisenc')
and gst.element_factory_find('oggmux') ):
controller.register_generic_feature(name, MontageRenderer)
else:
controller.log(_("Cannot register montage renderer: Gnonlin plugins are not present."))
if gst is not None:
CAPS_VIDEO_STRING = 'video/x-raw-yuv'
CAPS_VIDEO = gst.caps_from_string(CAPS_VIDEO_STRING)
CAPS_AUDIO_STRING = 'audio/x-raw-int;audio/x-raw-float'
CAPS_AUDIO = gst.caps_from_string(CAPS_AUDIO_STRING)
class MontageRenderer(object):
def __init__(self, controller, elements=None):
self.controller = controller
# self.elements is a list of annotations
if elements is None:
elements = []
self.elements = elements
self.encoding_pipe = None
def render(self, outputfile, progress_callback = None):
sourcefile = 'file:///' + self.controller.get_default_media()
if not sourcefile:
return
pipedef = "gnlcomposition name=videocomp caps=%s ! queue ! progressreport name=progress silent=true update-freq=1 ! identity single-segment=true ! ffmpegcolorspace ! videorate ! theoraenc ! multiqueue name=muxqueue ! oggmux name=mux ! filesink name=sink gnlcomposition name=audiocomp caps=%s ! queue ! identity single-segment=true ! audioconvert ! audiorate ! vorbisenc ! muxqueue." % (CAPS_VIDEO_STRING, CAPS_AUDIO_STRING)
pipe = gst.parse_launch(pipedef)
videocomp = pipe.get_by_name('videocomp')
audiocomp = pipe.get_by_name('audiocomp')
sink = pipe.get_by_name('sink')
bus = pipe.get_bus()
bus.enable_sync_message_emission()
def filesource(a, pos, caps):
"""Create a filesource.
"""
e = gst.element_factory_make('gnlfilesource')
e.set_property("location", sourcefile)
e.set_property("caps", caps)
e.set_property("start", pos * gst.MSECOND)
e.set_property("duration", a.fragment.duration * gst.MSECOND)
e.set_property("media-start", a.fragment.begin * gst.MSECOND)
e.set_property("media-duration", a.fragment.duration * gst.MSECOND)
return e
pos = 0
for a in self.elements:
e = filesource(a, pos, CAPS_VIDEO)
videocomp.add(e)
e = filesource(a, pos, CAPS_AUDIO)
audiocomp.add(e)
pos += a.fragment.duration
sink.set_property("location", outputfile)
def on_bus_message(bus, message):
if message.type == gst.MESSAGE_STATE_CHANGED:
old, new, pending = message.parse_state_changed()
print "STATE", old.value_nick, new.value_nick, pending.value_nick
elif message.type == gst.MESSAGE_EOS:
print " EOS"
pipe.set_state(gst.STATE_NULL)
progress_callback(None)
elif message.structure:
s=message.structure
print "MSG " + bus.get_name() + ": " + s.to_string()
if s.get_name() == 'progress' and progress_callback is not None:
progress_callback(s['percent-double'] / 100)
return True
bus.add_signal_watch()
bus.connect('message', on_bus_message)
pipe.set_state(gst.STATE_PLAYING)
self.encoding_pipe = pipe
return True
def finalize(self):
if self.encoding_pipe is not None:
self.encoding_pipe.set_state(gst.STATE_NULL)
self.encoding_pipe = None
# relpath, dump_bin and dump_element implementation based on Daniel Lenski
# posted on gst-dev mailing list on 20070913
def relpath(self, p1, p2):
sep = os.path.sep
# get common prefix (up to a slash)
common = os.path.commonprefix((p1, p2))
common = common[:common.rfind(sep)]
# remove common prefix
p1 = p1[len(common)+1:]
p2 = p2[len(common)+1:]
# number of seps in p1 is # of ..'s needed
return "../" * p1.count(sep) + p2
def dump_bin(self, bin, depth=0, recurse=-1, showcaps=True):
return [ l for e in reversed(list(bin)) for l in self.dump_element(e, depth, recurse - 1) ]
def dump_element(self, e, depth=0, recurse=-1, showcaps=True):
ret=[]
indentstr = depth * 8 * ' '
# print element path and factory
path = e.get_path_string() + (isinstance(e, gst.Bin) and '/' or '')
factory = e.get_factory()
if factory is not None:
ret.append( '%s%s (%s)' % (indentstr, path, factory.get_name()) )
else:
ret.append( '%s%s (No factory)' % (indentstr, path) )
# print info about each pad
for p in e.pads():
name = p.get_name()
# negotiated capabilities
caps = p.get_negotiated_caps()
if caps: capsname = caps[0].get_name()
elif showcaps: capsname = '; '.join(s.to_string() for s in set(p.get_caps()))
else: capsname = None
# flags
flags = []
if not p.is_active(): flags.append('INACTIVE')
if p.is_blocked(): flags.append('BLOCKED')
# direction
direc = (p.get_direction() is gst.PAD_SRC) and "=>" or "<="
# peer
peer = p.get_peer()
if peer: peerpath = self.relpath(path, peer.get_path_string())
else: peerpath = None
# ghost target
if isinstance(p, gst.GhostPad):
target = p.get_target()
if target: ghostpath = target.get_path_string()
else: ghostpath = None
else:
ghostpath = None
line=[ indentstr, " " ]
if flags: line.append( ','.join(flags) )
line.append(".%s" % name)
if capsname: line.append( '[%s]' % capsname )
if ghostpath: line.append( "ghosts %s" % self.relpath(path, ghostpath) )
line.append( "%s %s" % (direc, peerpath) )
#if peerpath and peerpath.find('proxy')!=-1: print peer
ret.append( ''.join(line) )
if recurse and isinstance(e, gst.Bin):
ret.extend( self.dump_bin(e, depth+1, recurse) )
return ret
def str_element(self, element):
return "\n".join(self.dump_element(element))
advene-1.0/lib/advene/plugins/shotdetectapp.py 0000644 0001752 0001752 00000012450 11547023677 021434 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
name="ShotDetectApp importer"
from gettext import gettext as _
import os
import sys
import re
import tempfile
import gobject
import advene.util.helper as helper
import advene.core.config as config
from advene.util.importer import ExternalAppImporter
def register(controller=None):
controller.register_importer(ShotdetectAppImporter)
return True
class ShotdetectAppImporter(ExternalAppImporter):
name = _("ShotdetectApp importer")
def __init__(self, *p, **kw):
super(ShotdetectAppImporter, self).__init__(*p, **kw)
self.app_path = config.data.path['shotdetect']
# Duration of the processed movie (used to correctly compute progress value)
self.duration = 0
self.sensitivity = 60
self.optionparser.add_option("-s", "--sensitivity",
action="store", type="int", dest="sensitivity", default=self.sensitivity,
help=_("Sensitivity of the algorithm. It should typically be between 50 and 80. If too many shots are detected, try to increase its value."))
def can_handle(fname):
"""Return a score between 0 and 100.
100 is for the best match (specific extension), 0 is for no match at all.
"""
ext = os.path.splitext(fname)[1]
if ext in config.data.video_extensions:
return 80
return 0
can_handle=staticmethod(can_handle)
def app_setup(self, filename, end_callback):
"""Setup various attributes/parameters.
You can for instance create temporary directories here. Add
them to self.temporary_resources so that they are cleaned up
in the end.
"""
if filename == self.controller.get_default_media():
# We know the duration
self.duration = self.controller.cached_duration
# FIXME: else we could/should get it somehow
self.tempdir = unicode(tempfile.mkdtemp('', 'shotdetect'), sys.getfilesystemencoding())
self.temporary_resources.append(self.tempdir)
self.ensure_new_type('shots', title=_("Detected shots"), schemaid='detected')
def get_process_args(self, filename):
"""Get the process args.
Return the process arguments (the app_path, argv[0], will be
prepended in async_process_file and should not be included here).
"""
if config.data.os == 'win32':
args = [ '-i', filename.encode('utf8', sys.getfilesystemencoding()),
'-o', self.tempdir.encode('utf8', sys.getfilesystemencoding()),
'-s', str(self.sensitivity) ]
else:
args = [ '-i', gobject.filename_from_utf8(filename.encode('utf8')),
'-o', gobject.filename_from_utf8(self.tempdir.encode('utf8')),
'-s', str(self.sensitivity) ]
return args
def iterator(self):
"""Process input data.
You can read the output from self.process.stdout or
self.process.stderr, or any other communication means provided
by the external application.
This method should yield dictionaries containing data (see
GenericImporter for details).
"""
shot_re=re.compile('Shot log\s+::\s+(.+)')
exp_re = re.compile('(\d*\.\d*)e\+(\d+)')
num = 1
begin = 0
while True:
l = self.process.stderr.readline()
if not l:
break
ms = shot_re.findall(l)
if ms:
ts = 0
try:
ts = long(ms[0])
except ValueError:
m = exp_re.match(ms[0])
if m:
ts = long(float(m.group(1)) * 10 ** int(m.group(2)))
if ts == 0:
continue
yield {
'content': str(num),
'begin': begin,
'end': ts,
}
begin = ts
num += 1
if self.duration > 0:
prg = 1.0 * ts / self.duration
else:
prg = None
if not self.progress(prg, _("Detected shot #%(num)d at %(pos)s ") % {
'num': num,
'pos': helper.format_time_reference(ts)
}):
break
# Generate last shot
yield {
'content': str(num),
'begin': begin,
'end': self.duration or (begin + 5000),
}
advene-1.0/lib/advene/plugins/__init__.py 0000644 0001752 0001752 00000001453 11341717667 020326 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
advene-1.0/lib/advene/plugins/undomanager.py 0000644 0001752 0001752 00000026730 11672132263 021062 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
"""Undo manager.
It provides a basic framework for simple undos.
"""
from advene.model.annotation import Annotation
from advene.model.fragment import MillisecondFragment
from advene.model.view import View
from advene.model.query import Query
from cPickle import dumps, loads
name="Undo Manager"
def register(controller):
controller.undomanager=UndoHistory(controller)
controller.undomanager.register()
class UndoHistory:
def __init__(self, controller=None):
self.controller=controller
# FIXME: history and _edits should be specific to each package
# In history, store triples (action, element, values)
# where action is 'batch', 'changed', 'deleted' or 'created'.
# If action is 'batch', then its element is the batch id, and
# its values is a history-like structure.
self.history=[]
# Hold intermediate batch_history. Only 1 batch can be active
# at a time.
self.batch_id=None
self.batch_history=None
self._rules=[]
self._edits={}
def register(self):
"""Register to the appropriate events.
"""
for (event, method) in (
('EditSessionStart', self.element_edit_begin),
('EditSessionEnd', self.element_edit_cancel),
('ElementEditDestroy', self.element_edit_cancel),
('AnnotationCreate', self.element_create),
('AnnotationEditEnd', self.element_edit_end),
('AnnotationDelete', self.element_delete),
('ViewCreate', self.element_create),
('ViewEditEnd', self.element_edit_end),
('ViewDelete', self.element_delete),
('QueryCreate', self.element_create),
('QueryEditEnd', self.element_edit_end),
('QueryDelete', self.element_delete),
):
r=self.controller.event_handler.internal_rule(event=event, method=method)
r.immediate=True
self._rules.append(r)
def unregister(self):
for r in self._rules:
self.controller.event_handler.remove_rule(r, 'internal')
def get_cached_representation(self, el):
"""Return a cached representation of an element.
"""
d={}
if hasattr(el, 'content'):
d['content']=str(el.content.data)
d['mimetype']=el.content.mimetype
if hasattr(el, 'fragment'):
d['begin']=long(el.fragment.begin)
d['end']=long(el.fragment.end)
if hasattr(el, 'tags'):
d['tags']=dumps(el.tags)
for a in ('id', 'title', 'author', 'date', 'viewableClass', 'type'):
if hasattr(el, a):
d[a]=getattr(el, a)
return d
def element_edit_begin(self, context, parameters):
"""Record the element values before edition.
"""
el=context.evaluateValue('element')
self._edits[el]=self.get_cached_representation(el)
#print "Recording cached for ", el
def element_edit_cancel(self, context, parameters):
"""Remove the value from the cache.
"""
el=context.evaluateValue('element')
try:
del self._edits[el]
#print "Removing cached value for ", el
except KeyError:
pass
def element_edit_end(self, context, parameters):
"""Record the modified elements.
"""
if context.globals.get('undone'):
# The change is done in the context of an Undo.
# Do not record it.
#print "EditEnd in Undo context"
return
batch=context.globals.get('batch', None)
if batch:
if batch == self.batch_id:
history=self.batch_history
else:
self.batch_id=batch
self.batch_history=[]
history=self.batch_history
self.history.append( ('batch', batch, history) )
else:
history=self.history
event=context.evaluateValue('event')
el=event.replace('EditEnd', '').lower()
element=context.evaluateValue(el)
if element in self._edits:
cached=self._edits[element]
new=self.get_cached_representation(element)
changed=[ (k, v) for (k, v) in cached.iteritems() if new[k] != v ]
# Store changed elements in history
history.append( ('changed', element, changed) )
self._edits[element]=new
#print "Saving diff for ", element
def element_create(self, context, parameters):
"""Record the created element id.
"""
if context.globals.get('undone'):
# The change is done in the context of an Undo.
# Do not record it.
#print "Create in Undo context"
return
event=context.evaluateValue('event')
el=event.replace('Create', '').lower()
element=context.evaluateValue(el)
batch=context.globals.get('batch', None)
if batch:
if batch == self.batch_id:
history=self.batch_history
else:
self.batch_id=batch
self.batch_history=[]
history=self.batch_history
self.history.append( ('batch', batch, history) )
else:
history=self.history
# Implicitly close a previous batch_history
if self.batch_id is not None:
self.batch_id=None
self.batch_history=[]
# Store created elements in history.
history.append( ('created', element, element.id) )
def element_delete(self, context, parameters):
"""Record the deleted elements.
"""
if context.globals.get('undone'):
# The change is done in the context of an Undo.
# Do not record it.
#print "Delete in Undo context"
return
event=context.evaluateValue('event')
el=event.replace('Delete', '').lower()
element=context.evaluateValue(el)
batch=context.globals.get('batch', None)
if batch:
if batch == self.batch_id:
history=self.batch_history
else:
self.batch_id=batch
self.batch_history=[]
history=self.batch_history
self.history.append( ('batch', batch, history) )
else:
history=self.history
# Implicitly close a previous batch_history
if self.batch_id is not None:
self.batch_id=None
self.batch_history=[]
if element in self._edits:
# Store deleted elements in history. We store here the
# element type (annotation, view...) as second parameter
history.append( ('deleted', el, self._edits[element]) )
del self._edits[element]
#print "Saving content for ", el
def log(self, *p):
self.controller.log("UndoManager: " + str(p))
def undo(self, operation=None):
"""Undo the last operation.
"""
if operation is not None:
(action, element, data)=operation
else:
if not self.history:
return
(action, element, data)=self.history.pop()
if action == 'changed':
for (k, v) in data:
if k in ('id', 'title', 'author', 'date', 'type'):
setattr(element, k, v)
elif k == 'content':
element.content.data=v
elif k == 'mimetype':
element.content.mimetype=v
elif k == 'begin':
element.fragment.begin=v
elif k == 'end':
element.fragment.end=v
elif k == 'tags':
element.tags=loads(v)
if isinstance(element, Annotation):
self.controller.notify('AnnotationEditEnd', annotation=element, undone=True)
elif isinstance(element, View):
self.controller.notify('ViewEditEnd', view=element, undone=True)
elif isinstance(element, Query):
self.controller.notify('QueryEditEnd', query=element, undone=True)
elif action == 'created':
self.controller.delete_element(element, undone=True)
elif action == 'deleted':
if element == 'annotation':
# Re-create the annotation
el=self.controller.package.createAnnotation(
ident=data['id'],
# FIXME: should check that the type still exists.
type=data['type'],
author=data['author'],
date=data['date'],
fragment=MillisecondFragment(begin=data['begin'],
end=data['end']))
el.content.data=data['content']
if 'tags' in data:
el.tags=loads(data['tags'])
self.controller.package.annotations.append(el)
el.complete=True
self.controller.notify('AnnotationCreate', annotation=el, undone=True)
elif element == 'view':
# Re-create the view
el=self.controller.package.createView(
ident=data['id'],
author=data['author'],
date=data['date'],
clazz=data['viewableClass'],
# FIXME: missing 1 item from matchfilter
content_mimetype=data['mimetype'],
)
el.title=data['title']
el.content.data=data['content']
el.content.mimetype=data['mimetype']
if 'tags' in data:
el.tags=loads(data['tags'])
self.controller.package.views.append(el)
self.controller.notify('ViewCreate', view=el, undone=True)
elif element == 'query':
# Re-create the query
el=self.controller.package.createQuery(ident=data['id'])
el.author=data['author']
el.date=data['date']
el.title=data['title']
el.content.mimetype=data['mimetype']
el.content.data=data['content']
if 'tags' in data:
el.tags=loads(data['tags'])
self.controller.package.queries.append(el)
self.controller.notify('QueryCreate', query=el, undone=True)
else:
self.log("Unknown element %s for undoing delete" % element)
elif action == 'batch':
for op in data:
self.undo(operation=op)
del data[:]
else:
self.log("Unknown operation %s for undo" % action)
advene-1.0/lib/advene/plugins/pocketsphinx.py 0000644 0001752 0001752 00000020150 11672132263 021267 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
name="Speech recognition"
from gettext import gettext as _
import os
import gobject
import gst
import advene.core.config as config
from advene.util.importer import GenericImporter
import advene.util.helper as helper
def register(controller=None):
if (gst.element_factory_find('vader')
and gst.element_factory_find('pocketsphinx')):
controller.register_importer(PocketSphinxImporter)
else:
controller.log(_("Cannot register speech recognition: Pocketsphinx plugins not found. See http://cmusphinx.sourceforge.net/wiki/gstreamer for details."))
return True
class PocketSphinxImporter(GenericImporter):
name = _("Speech recognition (PocketSphinx)")
def __init__(self, *p, **kw):
super(PocketSphinxImporter, self).__init__(*p, **kw)
# Noise level [0..1]
self.noise = 1.0 / 128
# Silence duration (in ms)
self.silence = 300
# Use default model
self.use_default_model = True
# Acoustic model (directory)
self.acoustic_model = "/usr/share/pocketsphinx/model/hmm/en_US/hub4wsj_sc_8k"
# Phonetic dictionary
self.phonetic_dict = "/usr/share/pocketsphinx/model/lm/en_US/cmu07a.dic"
# Lang model (lm)
self.lang_model = "/usr/share/pocketsphinx/model/lm/en_US/hub4.5000.DMP"
self.optionparser.add_option("-n", "--noise",
action="store", type="float", dest="noise", default=self.noise,
help=_("Filtering noise level [0..1]."))
self.optionparser.add_option("-s", "--silence",
action="store", type="int", dest="silence", default=self.silence,
help=_("Minimum amount (in milliseconds) of silence required to terminate the current annotation and start a new one. Decreasing this length will result in a large amount of short annotations and increasing this length will result in a small amount of long annotations."))
self.optionparser.add_option("-d", "--default-model",
action="store_true", dest="use_default_model", default= self.use_default_model,
help=_("Use default acoustic and language models."))
self.optionparser.add_option("-a", "--acoustic-model",
action="store", type="string", dest="acoustic_model", default=self.acoustic_model,
help=_("Acoustic model (directory)") + '[D]')
self.optionparser.add_option("-p", "--phonetic-dict",
action="store", type="string", dest="phonetic_dict", default=self.phonetic_dict,
help=_("Phonetic dictionary (.dic file)") + '[F]')
self.optionparser.add_option("-l", "--language-model",
action="store", type="string", dest="lang_model", default=self.lang_model,
help=_("Language model (.DMP file)") + '[F]')
self.buffer_list = []
self.start_position = 0
self.text = None
def can_handle(fname):
"""Return a score between 0 and 100.
100 is for the best match (specific extension), 0 is for no match at all.
"""
ext = os.path.splitext(fname)[1]
if ext in config.data.video_extensions:
return 80
return 0
can_handle=staticmethod(can_handle)
def on_vader_start(self, vader, pos):
"""Store start position.
"""
self.start_position = pos / gst.MSECOND
return True
def on_vader_stop(self, vader, pos):
"""Store stop position.
"""
if self.start_position and self.text:
self.buffer_list.append( (self.start_position, pos / gst.MSECOND, self.text) )
self.text = None
self.start_position = 0
return True
def on_pocketsphinx_result(self, sphinx, text, uttid):
self.text = text
return True
def generate_annotations(self):
n = 1.0 * len(self.buffer_list)
self.progress(0, _("Generating annotations"))
for i, tup in enumerate(self.buffer_list):
self.progress(i / n)
self.convert( [ {
'begin': tup[0],
'end': tup[1],
'content': tup[2],
} ])
def on_bus_message(self, bus, message):
def finalize():
"""Finalize data creation.
"""
gobject.idle_add(lambda: self.pipeline.set_state(gst.STATE_NULL) and False)
self.generate_annotations()
if self.end_callback:
self.end_callback()
return False
if message.type == gst.MESSAGE_EOS:
finalize()
elif message.structure:
s = message.structure
#print "MSG " + s.get_name() + ": " + s.to_string()
if s.get_name() == 'progress' and self.progress is not None:
if not self.progress(s['percent-double'] / 100, _("%(count)d utterances until %(time)s") % {
'count': len(self.buffer_list),
'time': helper.format_time(s['current'] * 1000) }):
finalize()
return True
def async_process_file(self, filename, end_callback=None):
self.end_callback = end_callback
at = self.ensure_new_type('speech', title=_("Speech"))
at.mimetype = 'text/plain'
at.setMetaData(config.data.namespace_prefix['dc'], "description", _("Recognized speech"))
if self.use_default_model:
args = ""
else:
args = 'hmm="%s" dict="%s" lm="%s" ' % (
self.acoustic_model,
self.phonetic_dict,
self.lang_model)
# Build pipeline
self.pipeline = gst.parse_launch('uridecodebin name=decoder ! audioconvert ! audioresample ! progressreport silent=true update-freq=1 name=report ! vader name=vader auto-threshold=false threshold=%(noise).9f run-length=%(silence)d ! pocketsphinx name=pocketsphinx %(pocketsphinxargs)s ! fakesink' % ( {
'noise': self.noise,
'silence': self.silence * gst.MSECOND,
'pocketsphinxargs': args }))
self.decoder = self.pipeline.get_by_name('decoder')
vader = self.pipeline.get_by_name("vader")
vader.connect("vader-start", self.on_vader_start)
vader.connect("vader-stop", self.on_vader_stop)
sphinx = self.pipeline.get_by_name("pocketsphinx")
sphinx.connect("result", self.on_pocketsphinx_result)
sphinx.set_property("configured", True)
bus = self.pipeline.get_bus()
# Enabling sync_message_emission will in fact force the
# self.progress call from a thread other than the main thread,
# which surprisingly works better ATM.
bus.enable_sync_message_emission()
bus.add_signal_watch()
bus.connect('sync-message', self.on_bus_message)
if config.data.os == 'win32':
self.decoder.props.uri = 'file:///' + os.path.abspath(unicode(filename))
else:
self.decoder.props.uri = 'file://' + os.path.abspath(filename)
self.progress(0, _("Recognizing speech"))
self.pipeline.set_state(gst.STATE_PLAYING)
return self.package
advene-1.0/lib/advene/plugins/tts.py 0000644 0001752 0001752 00000035057 11536167541 017404 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert
#
# Advene is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Advene 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Advene; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
from gettext import gettext as _
import subprocess
import os
import signal
import sys
import advene.core.config as config
from advene.rules.elements import RegisteredAction
import advene.util.helper as helper
import advene.model.tal.context
CREATE_NO_WINDOW = 0x8000000
name="Text-To-Speech actions"
ENGINES={}
def subprocess_setup():
# Python installs a SIGPIPE handler by default. This is usually not what
# non-Python subprocesses expect.
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
# Decorator. But using it would imply python >= 2.6.
def ttsengine(name):
def inside_register(f):
ENGINES[name] = f
return f
return inside_register
def register(controller=None):
engine_name = config.data.preferences.get('tts-engine', 'auto')
selected = None
if engine_name == 'auto':
# Automatic configuration. Order is important.
for name in ('customarg', 'custom', 'espeak', 'macosx', 'festival', 'sapi', 'generic'):
c = ENGINES[name]
if c.can_run():
controller.log("TTS: Automatically using " + c.__doc__.splitlines()[0])
selected = c
break
else:
c = ENGINES.get(engine_name)
if c is None:
controller.log("TTS: %s was specified but it does not exist. Using generic fallback. Please check your configuration." % c.__doc__.splitlines()[0])
selected = ENGINES['generic']
elif c.can_run():
controller.log("TTS: Using %s as specified." % c.__doc__.splitlines()[0])
selected = c
else:
controller.log("TTS: Using %s as specified, but it apparently cannot run. Please check your configuration." % c.__doc__.splitlines()[0])
selected = c
engine = selected(controller)
controller.register_action(RegisteredAction(
name="Pronounce",
method=engine.action_pronounce,
description=_("Pronounce a text"),
parameters={'message': _("String to pronounce.")},
defaults={'message': 'annotation/content/data'},
predefined={'message': (
( 'annotation/content/data', _("The annotation content") ),
)},
category='sound',
))
class TTSEngine:
"""Generic TTSEngine.
"""
def __init__(self, controller=None):
self.controller=controller
self.gui=self.controller.gui
self.language=None
def can_run():
"""Can this engine run ?
"""
return True
can_run=staticmethod(can_run)
def parse_parameter(self, context, parameters, name, default_value):
"""Helper method used in actions.
"""
if name in parameters:
try:
result=context.evaluateValue(parameters[name])
except advene.model.tal.context.AdveneTalesException, e:
try:
rulename=context.evaluateValue('rule')
except advene.model.tal.context.AdveneTalesException:
rulename=_("Unknown rule")
self.controller.log(_("Rule %(rulename)s: Error in the evaluation of the parameter %(parametername)s:") % {'rulename': rulename,
'parametername': name})
self.controller.log(unicode(e.message)[:160])
result=default_value
else:
result=default_value
return result
def set_language(self, language):
self.language=language
def pronounce(self, sentence):
"""Engine-specific method.
"""
self.controller.log("TTS: pronounce " + sentence)
return True
def action_pronounce (self, context, parameters):
"""Pronounce action.
"""
message=self.parse_parameter(context, parameters, 'message', _("No message..."))
self.pronounce(message)
return True
ENGINES['generic'] = TTSEngine
class FestivalTTSEngine(TTSEngine):
"""Festival TTSEngine.
Note: If it is not the case (depends on the version), festival
must be configured to play audio through the ALSA subsystem, in
order to be able to mix it with the movie sound if necessary.
For this, in older Festival versions (at least until 1.4.3), the
~/.festivalrc file should contain:
(Parameter.set 'Audio_Command "aplay -q -c 1 -t raw -f s16 -r $SR $FILE")
(Parameter.set 'Audio_Method 'Audio_Command)
"""
def __init__(self, controller=None):
TTSEngine.__init__(self, controller=controller)
self.festival_path=helper.find_in_path('festival')
self.aplay_path=helper.find_in_path('aplay')
if self.festival_path is None:
self.controller.log(_("TTS disabled. Cannot find the application 'festival' in PATH"))
if self.aplay_path is None:
self.controller.log(_("TTS disabled. Cannot find the application 'aplay' in PATH"))
self.festival_process=None
def init(self):
if self.festival_path is not None and self.aplay_path is not None:
if config.data.os == 'win32':
import win32process
kw = { 'creationflags': win32process.CREATE_NO_WINDOW }
else:
kw = { 'preexec_fn': subprocess_setup }
self.festival_process = subprocess.Popen([ self.festival_path, '--pipe' ], stdin=subprocess.PIPE, **kw)
# Configure festival to use aplay
self.festival_process.stdin.write("""(Parameter.set 'Audio_Command "%s -q -c 1 -t raw -f s16 -r $SR $FILE")\n""" % self.aplay_path)
self.festival_process.stdin.write("""(Parameter.set 'Audio_Method 'Audio_Command)\n""")
def can_run():
"""Can this engine run ?
"""
return (helper.find_in_path('festival') is not None)
can_run=staticmethod(can_run)
def pronounce (self, sentence):
try:
self.init()
if self.festival_process is not None:
self.festival_process.stdin.write('(SayText "%s")\n' % helper.unaccent(sentence))
except OSError, e:
self.controller.log(u"TTS Error: " + unicode(e.message))
return True
ENGINES['festival'] = FestivalTTSEngine
class MacOSXTTSEngine(TTSEngine):
"""MacOSX TTSEngine.
"""
def can_run():
"""Can this engine run ?
"""
return (config.data.os == 'darwin')
can_run=staticmethod(can_run)
def pronounce (self, sentence):
subprocess.call( [ '/usr/bin/say', sentence.encode(config.data.preferences['tts-encoding'], 'ignore') ] )
return True
ENGINES['macosx'] = MacOSXTTSEngine
"""
Win32: install pytts + pywin32 (from sf.net) + mfc71.dll + spchapi.exe (from www.microsoft.com/reader/developer/downloads/tts.mspx
)
On some flavors of Windows you can use:
import pyTTS
tts = pyTTS.Create()
tts.Speak('This is the sound of my voice.')
On Mac OS X you can use:
import os
http://farm.tucows.com/blog/_archives/2005/1/19/266813.html
http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/114216
http://www.daniweb.com/code/snippet326.html
http://www.mindtrove.info/articles/pytts.html
"""
class EspeakTTSEngine(TTSEngine):
"""Espeak TTSEngine.
"""
def __init__(self, controller=None):
TTSEngine.__init__(self, controller=controller)
self.language=None
self.espeak_path=helper.find_in_path('espeak')
if self.espeak_path is None and config.data.os == 'win32':
# Try c:\\Program Files\\eSpeak
if os.path.isdir('c:\\Program Files\\eSpeak'):
self.espeak_path='c:\\Program Files\\eSpeak\\command_line\\espeak.exe'
elif os.path.isdir('C:\\Program Files (x86)\\eSpeak'):
#winXp 64b
self.espeak_path='C:\\Program Files (x86)\\eSpeak\\command_line\\espeak.exe'
self.espeak_process=None
def can_run():
"""Can this engine run ?
"""
return (os.path.isdir('c:\\Program Files\\eSpeak') or os.path.isdir('C:\\Program Files (x86)\\eSpeak') or helper.find_in_path('espeak') is not None)
can_run=staticmethod(can_run)
def close(self):
"""Close the espeak process.
"""
if self.espeak_process is not None:
if config.data.os == 'win32':
import win32api
win32api.TerminateProcess(int(self.espeak_process._handle), -1)
else:
os.kill(self.espeak_process.pid, signal.SIGTERM)
self.espeak_process.wait()
self.espeak_process=None
def pronounce (self, sentence):
lang=config.data.preferences.get('tts-language', 'en')
if self.language != lang:
# Need to restart espeak to use the new language
self.close()
self.language=lang
try:
if self.espeak_process is None:
if config.data.os == 'win32':
import win32process
kw = { 'creationflags': win32process.CREATE_NO_WINDOW }
else:
kw = { 'preexec_fn': subprocess_setup }
self.espeak_process = subprocess.Popen([ self.espeak_path, '-v', self.language ], stdin=subprocess.PIPE, stdout=subprocess.PIPE, **kw)
self.espeak_process.stdin.write((sentence + "\n").encode(config.data.preferences['tts-encoding'], 'ignore'))
except OSError, e:
self.controller.log("TTS Error: ", unicode(e.message).encode('utf8'))
return True
ENGINES['espeak'] = EspeakTTSEngine
class SAPITTSEngine(TTSEngine):
"""SAPI (win32) TTSEngine.
"""
# SAPI constants (from http://msdn.microsoft.com/en-us/library/aa914305.aspx):
SPF_ASYNC = (1 << 0)
SPF_PURGEBEFORESPEAK = (1 << 1)
def __init__(self, controller=None):
TTSEngine.__init__(self, controller=controller)
self.sapi=None
def can_run():
"""Can this engine run ?
"""
try:
import win32com.client
voice = win32com.client.Dispatch("sapi.SPVoice")
except:
voice = None
return voice
can_run=staticmethod(can_run)
def pronounce (self, sentence):
if self.sapi is None:
import win32com.client
self.sapi=win32com.client.Dispatch("sapi.SPVoice")
self.sapi.Speak( sentence.encode(config.data.preferences['tts-encoding'], 'ignore'), self.SPF_ASYNC | self.SPF_PURGEBEFORESPEAK )
return True
ENGINES['sapi'] = SAPITTSEngine
class CustomTTSEngine(TTSEngine):
"""Custom TTSEngine.
It tries to run a 'prononce' ('prononce.bat' on win32) script,
which takes strings on its stdin and pronounces them.
"""
if config.data.os == 'win32':
prgname='prononce.bat'
else:
prgname='prononce'
def __init__(self, controller=None):
TTSEngine.__init__(self, controller=controller)
self.language=None
self.prg_path=helper.find_in_path(CustomTTSEngine.prgname)
self.prg_process=None
def can_run():
"""Can this engine run ?
"""
return helper.find_in_path(CustomTTSEngine.prgname) is not None
can_run=staticmethod(can_run)
def close(self):
"""Close the process.
"""
if self.prg_process is not None:
if config.data.os == 'win32':
import win32api
win32api.TerminateProcess(int(self.prg_process._handle), -1)
else:
os.kill(self.prg_process.pid, signal.SIGTERM)
self.prg_process.wait()
self.prg_process=None
def pronounce (self, sentence):
lang=config.data.preferences.get('tts-language', 'en')
if self.language != lang:
self.close()
self.language=lang
try:
if self.prg_process is None:
self.prg_process = subprocess.Popen([ self.prg_path, '-v', self.language ], stdin=subprocess.PIPE, stdout=subprocess.PIPE, creationflags = CREATE_NO_WINDOW)
self.prg_process.stdin.write((sentence + "\n").encode(config.data.preferences['tts-encoding'], 'ignore'))
except OSError, e:
self.controller.log("TTS Error: ", unicode(e.message).encode('utf8'))
return True
ENGINES['custom'] = CustomTTSEngine
class CustomArgTTSEngine(TTSEngine):
"""CustomArg TTSEngine.
It tries to run a 'prononcearg' ('prononcearg.bat' on win32) script,
which takes strings as arguments and pronounces them.
"""
if config.data.os == 'win32':
prgname='prononcearg.bat'
else:
prgname='prononcearg'
def __init__(self, controller=None):
TTSEngine.__init__(self, controller=controller)
self.language=None
self.prg_path=helper.find_in_path(CustomArgTTSEngine.prgname)
def can_run():
"""Can this engine run ?
"""
return helper.find_in_path(CustomArgTTSEngine.prgname) is not None
can_run=staticmethod(can_run)
def close(self):
"""Close the process.
"""
pass
def pronounce (self, sentence):
lang=config.data.preferences.get('tts-language', 'en')
if self.language != lang:
self.close()
self.language=lang
try:
fse = sys.getfilesystemencoding()
subprocess.Popen(unicode(" ".join([self.prg_path, '-v', self.language, '"%s"' % (sentence.replace('\n',' ').replace('"', '') + u"\n")])).encode(config.data.preferences['tts-encoding'], 'ignore'), creationflags = CREATE_NO_WINDOW)
except OSError, e:
try:
m = unicode(e.message)
except UnicodeDecodeError:
print "TTS: Error decoding error message with standard encoding"
m = unicode(e.message, fse, 'ignore')
self.controller.log("TTS Error: ", m.encode('ascii', 'ignore'))
return True
ENGINES['customarg'] = CustomArgTTSEngine
advene-1.0/lib/advene/plugins/fcp.py 0000644 0001752 0001752 00000007201 11642631324 017321 0 ustar oaubert oaubert #
# Advene: Annotate Digital Videos, Exchange on the NEt
# Copyright (C) 2008 Olivier Aubert