original.py

这个P2P 环境下基于 PEERS 内核 的 实时视频流的协议

#!/usr/bin/env python
# -*- Python -*-
#| This file is part of the VidTorrent Project
#| http://viral.media.mit.edu/index.php?page=vidtorrent
#|
#| File: vidtorrent/src/veep/veep2.py
#| Version: $Id: veep2.py,v 1.8 2006/05/15 03:30:18 vyzo Exp $
#| Content: veep 1.1 vidtorrent client
#|
#| Copyright (C) 2005,2006 Dimitris Vyzovits [[e-mail]]
#|                         MIT Media Laboratory
#|
#| 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, Boston, MA  02110-1301, USA
#| 
#

import peers, peers.rewire as rewire, vt2, vt2.proto
import sys, socket, os, binascii, shelve, re
import pygtk, gtk, gtk.glade, gobject, pango
import gnome.ui

from peers import events, wrap

rurl = re.compile( 'http://(?P<host>.*)(?P<path>/.*)' )
## defaults
usettings = os.path.join( os.getenv( 'HOME' ), ".veep2.pyo" )
uconfig = shelve.open( usettings )
user = "anonymous"
rewire_seed = "inet:rewire.media.mit.edu"
#rewire_seed = 'inet:localhost'
#rewire_seed = 'inet:10.0.0.2'
bandwidth = 1024
registry = 'dictionary'
#VLC = "vlc -V x11 -I dummy http://localhost:%d/"
VLC = "vlc -V x11 -I dummy http://localhost:%d/ --sout=#std{access=file,mux=ts,dst=10111.avi}"
#SZ
#VLC = "vlc http://localhost:%d/"
veep = None
node = None
session = None

def gtk_delay( f, *args ):
    gobject.timeout_add( 0, f, *args )

def in_gtk_loop( f ):
    def _c( *args ):
        gtk_delay( f, *args )
    return peers.callable_wrapper( _c, f )

def get_widgets( wset, *xs ):
    return map( lambda x: wset.get_widget( x ), xs )

class veep_main( object ):
    License = "GNU GPLv2"
    Copyright = "(C) 2006 MIT Media Laboratory"
    Authors = ["Dimitris Vyzovitis [[e-mail]]",
               "Ilia Mirkin [[e-mail]]" ]
    URL = "http://viral.media.mit.edu"
    
    def __init__( self ):
        #SZ
        self.widgets = gtk.glade.XML( "../../src/veep/veep2.glade", 'veep_main' )
        self.widgets.signal_autoconnect( self )
        self.win = self.widgets.get_widget( 'veep_main' )
        self.win.set_title( "Veep: %s" % user )
        self.about = None
        self.watching = None
        self.providing = None
        self.__streamview()

    def __streamview( self ):
        model = gtk.ListStore( str, bool, bool, object )
        ## put some junk
        self.streamview = self.widgets.get_widget( 'streamlist' )
        self.streamview.set_model( model )
        sel = self.streamview.get_selection()
        sel.set_mode( gtk.SELECTION_MULTIPLE )
        render = gtk.CellRendererText()
        render.set_property( 'weight', pango.WEIGHT_BOLD )
        render.set_property( 'background', 'lightgray' )
        render.set_property( 'foreground', 'red' )
        x = gtk.TreeViewColumn( None, render, text=0,
                                weight_set=1, background_set=1,
                                foreground_set=2 )
        self.streamview.append_column( x )
        self.streamview.connect( 'row-activated', self.on_open_stream )

    def refresh( self ):
        def _cc( sinfo, ident, proto ):
            print "found stream: %s" % sinfo.name
            assert sinfo.name != self.providing
            sinfo.ident = ident
            sinfo.proto = proto
            model = self.streamview.get_model()
            for x in model:
                name = model.get_value( x.iter, 0 )
                if name == sinfo.name:
                    info = model.get_value( x.iter, 3 )
                    print "info: %s" % info
                    if not info:
                        model.set_value( x.iter, 3, sinfo )
                    break
            else:
                model.append( [sinfo.name, False, False, sinfo] )
        
        def _get_info( sources ):
            for (ident, proto) in sources:
                print "Source: %s" % binascii.hexlify( ident )
                n = peers.connect( vt2.proto.metadata.node, proto )
                n.get_info( in_gtk_loop( wrap( _cc, ident, proto )),
                            peers.warn )

        print "lookup sources"
        session.lookup( registry, _get_info, peers.warn )
    
    ## gtk callbacks
    def on_open_stream( self, view, path, column ):
        model = view.get_model()
        x = model.get_iter( path )
        sinfo = model.get( x, 3 )[0]
        if sinfo:
            if ((sinfo.name == self.providing)
                or (self.watching and (sinfo.name == self.watching.name))):
                return
            else:
                if self.watching:
                    self.watching.destroy()
                print "open_stream: %s" % sinfo.name
                self.watching = veep_stream( sinfo, self.close_stream )
                model.set( x, 1, True )

    def close_stream( self, name ):
        print "close stream %s" % name
        model = self.streamview.get_model()
        if self.watching and (name == self.watching.name):
            self.watching = None
            for x in model:
                xname = model.get_value( x.iter, 0 )
                if xname == name:
                    model.set_value( x.iter, 1, False )
                    if not model.get_value( x.iter, 3 ):
                        model.remove( x.iter )
                    break
        elif self.providing and (name == self.providing.name):
            self.providing = None
            self.widgets.get_widget( 'new' ).set_sensitive( True )
            for x in model:
                xname = model.get_value( x.iter, 0 )
                if xname == name:
                    model.remove( x.iter )
                    break
        else:
            print "bogus stream"

    def on_refresh( self, w ):
        print "Refresh"
        model = self.streamview.get_model()
        model.clear()
        if self.providing:
            model.append( (self.providing.name, True, True, None))
        if self.watching:
            model.append( (self.watching.name, True, False, None))
        self.refresh()

    def on_quit( self, w, *args ):
        print "User quit"
        sys.exit( 0 )
        
    def on_new( self, w ):
        print "New"
        assert not self.providing
        ## FIXME: remove sources bullshit, window
        sdata = veep_new()
        if not sdata: return
        
        name, host, path, bitrate, trees = sdata
        ninfo = vt2.proto.node_info( session.ident,
                                     session.proto, session.proto )
        ninfo.endpoint = session.endpoint
        sinfo = vt2.proto.stream_info( session.ident, "", [],
                                       bitrate, 1, trees )
        source = vt2.source.http_source( ninfo, sinfo, name, 0, host, path,
                                         xprobe = node.probe )

        self.providing = veep_source( source, sinfo, self.close_stream )
        ## housekeeping
        model = self.streamview.get_model()
        model.append( (name, True, True, None))
        ## XXX single provider for now (the metadata kludge in vt breaks shit)
        self.widgets.get_widget( 'new' ).set_sensitive( False )

    def on_settings( self, w ):
        print "Settings"
        veep_settings()

    def on_about( self, w ):
        def destroy( *args ):
            self.about.destroy()
            self.about = None

        print "About"
        if not self.about:
            self.about = gnome.ui.About( name = "Veep",
                                         version = "1.1",
                                         copyright = self.Copyright,
                                         comments = self.URL,
                                         authors = self.Authors )
            self.about.connect( 'destroy', destroy )
        self.about.show_all()

class veep_stream_base( object ):
    class _x( object ): pass

    def __init__( self, node, sinfo, close, check_widgets = None ):
        self.node = node
        self.sinfo = sinfo
        self.name = sinfo.name
        self.close = close
        ## configure the node
        self.node.chatter = in_gtk_loop( self.recv )
        self.player = None
        self.widgets = gtk.glade.XML( "../../src/veep/veep2.glade", 'veep_stream' )
        self.widgets.signal_autoconnect( self )
        if check_widgets:
            check_widgets( self.widgets )
        self.win = self.widgets.get_widget( 'veep_stream' )
        self.win.set_title( self.name )
        self.win.show_all()
        self.buttons = self._x()
        (self.noise,
         self.babblings,
         self.buttons.join,
         self.buttons.play,
         self.buttons.stop,
         self.buttons.leave,
         self.buttons.say) = get_widgets( self.widgets,
                                          'history',
                                          'babblings',
                                          'join',
                                          'play',
                                          'stop',
                                          'leave',
                                          'say' )
        self._create_tags()
        self._disconnected( None )

    def _create_tags( self ):
        buf = self.noise.get_buffer()
        buf.create_tag( 'big',
                        weight = pango.WEIGHT_BOLD,
                        size = 15 * pango.SCALE )
        buf.create_tag( 'log',
                        foreground = 'gray' )
        buf.create_tag( 'red',
                        foreground = 'firebrick4' )
        buf.create_tag( 'blue',
                        foreground = 'navy' )

    def _disconnected( self, action = "disconnected" ):
        self.active = False
        self.trees = 0
        if action:
            self._set_status( action )
            self._log( action )
        if self.player:
            self._stop()
        self._reset_buttons()

    def _connected( self, action = "connected" ):
        if action:
            self._set_status( action )
        self._enable( self.buttons.play )
        self._enable( self.buttons.leave )
        self._enable( self.buttons.say )

    def _disable( self, x ):
        x.set_sensitive( False )

    def _enable( self, x ):
        x.set_sensitive( True )

    def _reset_buttons( self ):
        self._enable( self.buttons.join )
        self._disable( self.buttons.play )
        self._disable( self.buttons.leave )
        self._disable( self.buttons.stop )
        self._disable( self.buttons.say )

    def _set_status( self, x ):
        self.win.set_title( "%s: %s (%s)" % (self.name, user, x) )

    def _log( self, x ):
        buf = self.noise.get_buffer()
        buf.insert_with_tags_by_name( buf.get_end_iter(), x, 'log' )
        buf.insert( buf.get_end_iter(), "\n" )

    def _play( self ):
        assert self.player is None