VLS Comments/suggestions/questions....

Thu Mar 21 22:38:00 CET 2002

1) While the Kfir interface is a nice thought,
it seems far away due to a lot of practical
considerations - well, let me rephrase, it
only supports a single card that's much more
expensive than your typical $60 TV card.

Would it make sense to also provide a direct interface
to the V4L or V4L2 device and insert a software
real-time conversion to PS and/or TS?  This would be
useful for a lot more people/video cards out there, and
several projects seem to be handling this conversion
without hardware support. (ffmpeg, mp1e, etc.)

2) I don't know what the status is on the NativeAdmin
interface, but I see two relatively easy ways to
provide control - a simple HTTP interface, and an
XML-RPC interface. You already have an authentication
method available, so having a simple HTTP daemon
running to do WWW-authenticate: Basic and Authorization: Basic
via your mkpassword file. The GET interface is sufficient as
a start:

 HTTP/1.0 GET /group1?user=bill&password=bermuda&command=start&\
    program=snowboarding&channel=sports&input=olympics

For a start, the interface would only have to implement:
start,stop,suspend,resume,browse,shutdown. It would
be simple to write a page or two with drop-down options
to redirect to a Videolan HTTP interface, instead of
the clumsier telnet interface. The server
could even be written from scratch - it just has to
parse a single GET command, and be able to write:

<html><head>VLS</head><body>
Programs:<p>
Snowboarding provided by news olympics<p>
Golf provided by sportsummary<p>
....
</body></html>

However, there are some small http servers that might tie in
nicer and be more flexible for later expansion. (libwww is
a bit bloated I've heard, but there are some lightweight
ones available - XMLRPC-C uses Abyss now).

Another option is XML-RPC, which allows XML-based
remote calls pretty trivially.
[There's new support in Python2.2 support,
though I imagine Eric Kidd's XMLRPC-C
C libraries are pretty well defined by now
as well - http://xmlrpc-c.sf.net]

A sample server would be:

  import SimpleXMLRPCServer,string

  def test_case(myvals):
    result=string.join(myvals,":")
    return result

  vls=SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost",9997))
  vls.register_function(test_case)
  vls.serve_forever()

And an example Python client is:

  import xmlrpc, base64

  vls_rpc = xmlrpclib.Server("http://localhost:9997")
  status = 
vls_rpc.test_case("start",(base64.encode("bill:bermuda),"start",
      "snowboarding","sports","olympics"))
  print status

which prints:

	'YmlsbDpiZXJtdWRh\n:start:snowboarding:sports:olympics'

Some C sample clients/servers, only slightly more complicated,
are at:

 http://xmlrpc-c.sourceforge.net/sample-code.php

3) Lastly, I'll repeat a thought I had before, which is
that vls could use an additional parameter to position itself
within a file it's streaming. (perhaps by time and by byte-count).
A live streaming function might be archiving on disk, and give
the viewer the option to either tune in on the live program
(the program being transferred directly from card to network),
or choose to tune in from the beginning of the program, or
somewhere in the middle, including skipping ahead a couple of
minutes to miss commercials, etc.)

Anyway, food for thought as they say.

Cheers,
Bill
-- 
Bill Eldridge
Radio Free Asia
bill at rfa.org

-- 
This is the vls-devel mailing-list, see http://www.videolan.org/vls-devel/
To unsubscribe, please read http://www.videolan.org/lists.html
If you are in trouble, please contact <postmaster at videolan.org>