original.py

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

        cmd = (VLC % self.node.http.port).split()
        print reduce( lambda x, y: "%s %s" % (x, y), cmd )
        self.player = os.spawnlp( os.P_NOWAIT, 'vlc', *cmd )
        self._disable( self.buttons.play )
        self._enable( self.buttons.stop )

    def _stop( self ):
        assert self.player is not None
        os.kill( self.player, 9 )
        os.waitpid( self.player, os.WNOHANG )
        self.player = None
        self._enable( self.buttons.play )
        self._disable( self.buttons.stop )

    def _babbling( self, who, what ):
        if who == user:
            tag = 'blue'
        else:
            tag = 'red'

        buf = self.noise.get_buffer()
        buf.insert_with_tags_by_name( buf.get_end_iter(), "%s: " % who, tag )
        buf.insert( buf.get_end_iter(), what )
        buf.insert( buf.get_end_iter(), "\n" )

    def _send( self, x ):
        print "send %s" % x
        events.delay( wrap( self.node.send_message, user, x ))

    @in_gtk_loop
    def recv( self, whtvr, name, babbling ):
        print "Babbling: %s: %s" % (name, babbling)
        self._babbling( name, babbling )

    def on_join( self, *args ):
        print "join stream"
        self._join()

    def on_leave( self, *args ):
        print "leave stream"
        assert self.active
        self._leave()

    def on_play( self, *args ):
        print "play stream"
        self._play()

    def on_stop( self, *args ):
        print "stop stream"
        self._stop()

        
    def on_say( self, *args ):
        print "say it!"
        buf = self.babblings.get_buffer()
        x = buf.get_text( buf.get_start_iter(), buf.get_end_iter(), False )
        if x:
            buf.delete( buf.get_start_iter(), buf.get_end_iter() )
            self._babbling( user, x )
            self._send( x )

class veep_stream( veep_stream_base ):
    def __init__( self, sinfo, close ):
        veep_stream_base.__init__( self, node, sinfo, close )

    def _join( self ):
        self._set_status( "connecting..." )
        ident = self.sinfo.ident
        proto = self.sinfo.proto
        self._log( "connecting..." )
        self.node.connect( [vt2.proto.node_info( ident, proto, proto )], self )
        self.active = True
        self._disable( self.buttons.join )

    def _leave( self ):
        events.delay( self.node.disconnect_all )
        self._disconnected()
        

    @in_gtk_loop
    def attach( self, x ):
        if self.active:
            self.trees += 1
            self._log( "attached (%d/%d)" \
                        % (self.trees, len( self.sinfo.streams )))
            if self.trees == len( self.sinfo.streams ):
                self._connected()

    @in_gtk_loop
    def detach( self, x ):
        if self.active:
            self.trees -= 1
            self._log( "detached (%d/%d)" \
                        % (self.trees, len( self.sinfo.streams )))

    @in_gtk_loop
    def error( self, x, e ):
        if self.active and isinstance( e, vt2.node.disconnected ):
            self._disconnected()

    def destroy( self, *args ):
        if self.active:
            self._leave()
        self.win.destroy()
        self.close( self.name )

class veep_source( veep_stream_base ):
    def __init__( self, source, sinfo, close ):
        veep_stream_base.__init__( self, source, sinfo, close,
                                   self.__modbuttons )
        self.running = True
        self.node.start( self.error )
        self.node.pause()
        session.publish( self.name )
        session.publish( registry )

    def __modbuttons( self, widgets ):
        widgets.get_widget( "label7" ).set_text( "Capture" )
        widgets.get_widget( "image9" ).set_from_stock( gtk.STOCK_MEDIA_RECORD, 4 )
        widgets.get_widget( "label4" ).set_text( "Watch" )
        widgets.get_widget( "image6" ).set_from_stock( gtk.STOCK_FULLSCREEN, 4 )
        widgets.get_widget( "label5" ).set_text( "Hide" )
        widgets.get_widget( "image7" ).set_from_stock( gtk.STOCK_LEAVE_FULLSCREEN, 4 )
        widgets.get_widget( "label6" ).set_text( "Pause" )
        widgets.get_widget( "image8" ).set_from_stock( gtk.STOCK_MEDIA_PAUSE, 4 )
        
    def _join( self ):
        self.active = True
        self.node.resume()
        self._disable( self.buttons.join )
        self._connected( "capturing" )
        self._log( "capturing" )

    def _leave( self ):
        if self.player:
            self._stop()
        self.node.pause()
        self._disconnected( "paused" )

    @in_gtk_loop
    def error( self, e ):
        if self.running:
            self.running = False
            veep_notify_user( gtk.MESSAGE_ERROR, "There is no video feed! Perhaps you should check that your video source is still running?" )
            self.win.hide()
            self.destroy()
            gtk.main()


    def destroy( self, *args ):
        if self.active:
            events.delay( self.node.stop )
            self._leave()
        self.win.destroy()
        self.close( self.name )
        session.retract( self.name )
        session.retract( registry )


def veep_new():
    def _validate( name, brate, url, trees ):
        if not name:
            raise ValueError, "No stream name specified"
        if brate > bandwidth:
            ## XXX check for currently available bandwidth?
            raise ValueError, "Insufficient bandwidth"
        if not rurl.match( url ):
            raise ValueError, "Malformed URL"
        host, path = rurl.match( url ).groups()
        ## grrr... name is a tuple for some reason"
        return (name[0], peers.parse_address( 'inet:%s' % host ), path,
                brate, trees)
        
    widgets = gtk.glade.XML( "../../src/veep/veep2.glade", 'veep_new' )
    dlg, xtrees, xbitrate, xurl, xname = get_widgets( widgets,
                                                      'veep_new',
                                                      'new_trees',
                                                      'new_bitrate',
                                                      'new_url',
                                                      'new_name' )
    xname.set_text( "%s's webcam" % user )
    r = None
    while True:
        x = dlg.run()
        try:
            if x == gtk.RESPONSE_OK:
                name = xname.get_text(),
                bitrate = int( xbitrate.get_text() )
                url = xurl.get_text()
                trees = int( xtrees.get_value())
                r = _validate( name, bitrate, url, trees )
                break
            else:
                break
        except ValueError, e:
            peers.warn( e )
            veep_notify_user( gtk.MESSAGE_ERROR, str(e))
    dlg.destroy()
    return r

def veep_notify_user( t, x ):
    dlg = gtk.MessageDialog( flags = gtk.DIALOG_MODAL,
                             type = t,
                             buttons = gtk.BUTTONS_OK,
                             message_format = x )
    dlg.run()
    dlg.hide()
    dlg.destroy()

def veep_settings( boot = False ):
    def _validate( user, bw, seed ):
        if not user:
            raise ValueError, "Invalid user handle"
        if int( bw ) < 256:
            raise ValueError, "Insufficient bandwidth"
        return peers.parse_proto_entry( seed )
    
    global bandwidth, rewire_seed, user

    widgets = gtk.glade.XML( "../../src/veep/veep2.glade", 'veep_settings' )
    dlg, xbw, xrewire, xuser = get_widgets( widgets,
                                            'veep_settings',
                                            'settings_bw',
                                            'settings_rewire',
                                            'settings_user' )
    xbw.set_value( bandwidth )
    xrewire.set_text( rewire_seed )
    xuser.set_text( user )
    
    while True:
        x = dlg.run()
        try:
            if x == gtk.RESPONSE_OK:
                u = xuser.get_text()
                bw = int( xbw.get_value())
                rs = xrewire.get_text()
                seed = _validate( u, bw, rs )
                user = uconfig['user'] = u
                bandwidth = uconfig['bandwidth'] = bw
                rewire_seed = uconfig['rewire_seed'] = rs
                uconfig.sync()
                print "user: %s bandwidth: %s seed: %s" % (user, bandwidth, seed)
                if boot:
                    events.delay( wrap( start_node, seed ))
                else:
                    veep_notify_user( gtk.MESSAGE_INFO,
                                      "New settings will take effect the next time you run veep" )
                break
            elif boot:
                sys.exit( 0 )
            else:
                break
        except ValueError, e:
            peers.warn( e )
            veep_notify_user( gtk.MESSAGE_ERROR, str(e))
        except socket.gaierror, e:
            peers.warn( e )
            veep_notify_user( gtk.MESSAGE_ERROR, e.args[1] )

    dlg.destroy()
    gtk.main()

def error( e ):
    print "error: %s" % e
    sys.exit( 1 )

def start_node( seed ):
    rewire.join( [seed], None, rewire_join, error )

def start_veep():
    print "Start Veep ....."
    global session, veep, node
    session = rewire.open_session()
    ninfo = vt2.proto.node_info( session.ident, session.proto, session.proto )
    node = vt2.node.local_node(ninfo, bandwidth )
    veep = veep_main()
    veep.refresh()

def rewire_join():
    gtk_delay( start_veep )



if __name__ == '__main__':
    if len( sys.argv ) > 1:
        user = sys.argv[1]
    elif 'user' in uconfig:
        user = uconfig['user']
        
    if len( sys.argv ) > 2:
        rewire_seed = sys.argv[2]
    elif 'rewire_seed' in uconfig:
        rewire_seed = uconfig['rewire_seed']
        
    if len( sys.argv ) > 3:
        bandwidth = int( sys.argv[3] )
    elif 'bandwidth' in uconfig:
        bandwidth = uconfig['bandwidth']

    seed = peers.parse_proto_entry( rewire_seed )
    gtk.gdk.threads_init()
    gnome.init( "Veep", "1.1" )
    
    events.spawn_loop()

    gtk_delay( veep_settings, True )
    gtk.main()