コード例 #1
0
 def setElement(self, element, properties={}, ignore=['name']):
     """ Set given element on Widget, with optional properties """
     gst.info("element:%s, properties:%s" % (element, properties))
     self.element = element
     self.ignore = ignore
     self.properties = {} #key:name, value:widget
     self._addWidgets(properties)
コード例 #2
0
    def parseEvent(self, buffer):
        """
        Take in a 12-byte string and extract out the command
        to see if it's an audio command. 

        """
        
        CMD = 'B'
        SRC = 'B'

        cmd = unpack(CMD, buffer[0:1])[0]
        
        if cmd != self.AUDIO_BCAST_CMD:
            gst.info("Parsing Events, CMD IS NOT :" +  str(self.AUDIO_BCAST_CMD) + '  CMD IS:' +  str(cmd)) 
            return ""
        
        #data = np.fromstring(buffer[4:], dtype=np.int16)
        #print data
        #datas = data.astype(np.float)
        #scaled = (data * 1) # .astype(np.int16)
        #scaled = scaled.astype(">h")
        #scaled = np.array([0, 2**15-1, 0, 2**15-1], dtype=np.int16)
        #buffer_out = scaled.tostring()
        #gst.error("HELLO") # %s" % data)
        buffer_out = buffer[4:]
        return buffer_out
コード例 #3
0
ファイル: pyzm_player.py プロジェクト: rlrosa/pyzm-player
 def run(self):
     self.gstBus = self.args[0]
     self.cb  = self.args[1]
     self.gstBus.add_signal_watch()
     self.gstBus.connect('message', self.cb)
     self.loop = gobject.MainLoop()
     gst.info('Running gst listener thread')
     self.loop.run()
コード例 #4
0
ファイル: pmt.py プロジェクト: clones/kaa
 def __init__(self, dvbsrc, *args):
     gst.Element.__init__(self)
     gst.info('creating sinkpad')
     pad = gst.Pad(self._sinkpadtemplate, "sink")
     pad.set_chain_function(self.chainfunc)
     self.add_pad(pad)
     self.buffer = {}
     self.parse_args = args
     self.dvbsrc = dvbsrc
コード例 #5
0
    def _new_decoded_pad_cb(self, dbin, pad, is_last):
        # Does the file contain got audio or video ?
        caps = pad.get_caps()
        gst.info("caps:%s" % caps.to_string())
        if "audio" in caps.to_string():
            self.is_audio = True
        elif "video" in caps.to_string():
            self.is_video = True
        else:
            self.warning("got a different caps.. %s" % caps.to_string())
            return
        if is_last and not self.is_video and not self.is_audio:
            self.debug("is last, not video or audio")
            self._finished(False)
            return
        # we connect a fakesink to the new pad...
        pad.info("adding queue->fakesink")
        fakesink = gst.element_factory_make(
            "fakesink", "fakesink%d-%s" % (self.sinknumber, "audio" in caps.to_string() and "audio" or "video")
        )
        self.sinknumber += 1
        queue = gst.element_factory_make("queue")
        # we want the queue to buffer up to the specified amount of data
        # before outputting. This enables us to cope with formats
        # that don't create their source pads straight away,
        # but instead wait for the first buffer of that stream.
        # The specified time must be greater than the input file
        # frame interleave for the discoverer to work properly.
        queue.props.min_threshold_time = int(self._max_interleave * gst.SECOND)
        queue.props.max_size_time = int(2 * self._max_interleave * gst.SECOND)
        queue.props.max_size_bytes = 0

        # If durations are bad on the buffers (common for video decoders), we'll
        # never reach the min_threshold_time or max_size_time. So, set a
        # max size in buffers, and if reached, disable the min_threshold_time.
        # This ensures we don't fail to discover with various ffmpeg
        # demuxers/decoders that provide bogus (or no) duration.
        queue.props.max_size_buffers = int(100 * self._max_interleave)

        def _disable_min_threshold_cb(queue):
            queue.props.min_threshold_time = 0
            queue.disconnect(signal_id)

        signal_id = queue.connect("overrun", _disable_min_threshold_cb)

        self.add(fakesink, queue)
        queue.link(fakesink)
        sinkpad = fakesink.get_pad("sink")
        queuepad = queue.get_pad("sink")
        # ... and connect a callback for when the caps are fixed
        sinkpad.connect("notify::caps", self._notify_caps_cb)
        if pad.link(queuepad):
            pad.warning("##### Couldn't link pad to queue")
        queue.set_state(gst.STATE_PLAYING)
        fakesink.set_state(gst.STATE_PLAYING)
        gst.info("finished here")
コード例 #6
0
ファイル: bbc.py プロジェクト: haniokasai/netwalker-rootfs
	def playEpisode (self, view, episode):
		gst.info('Playing episode ' + episode.title)
		mrl = episode.getUri(self.getConnectionSpeed())
		if mrl:
		  gst.log('Playing uri ' + mrl)
		  self.totem.action_set_mrl_and_play(mrl, None)
		  #self.totem.action_remote(totem.REMOTE_COMMAND_ENQUEUE, mrl)
		  #self.totem.action_remote(totem.REMOTE_COMMAND_PLAY, mrl)
		else:
		  gst.error('No uri for episode ' + episode.title)
コード例 #7
0
    def stop(self):
        self.player.set_state(gst.STATE_NULL)
        gst.info("stopped player")
	self.playing = False
        if self._temp_location:
            try:
                os.unlink(self._temp_location)
            except OSError:
                pass
            self._temp_location = ''
コード例 #8
0
ファイル: sink.py プロジェクト: Emat12/ndnvideo
	def __init__(self):
		gst.Element.__init__(self)

		gst.info("Creating CCN Sink")
		self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")

		gst.info("Adding sinkpad to self")
		self.add_pad(self.sinkpad)

		self.sinkpad.set_chain_function(self.chainfunc)
		self.sinkpad.set_event_function(self.eventfunc)
コード例 #9
0
ファイル: KaicongAudioGst.py プロジェクト: bossjones/Jarvis
 def set_property(self, name, value):
     if name == 'ip':
         self.ip = value
     elif name == 'user':
         self.user = value
     elif name == "pwd":
         self.pwd = value
     elif name == "on" and value:
         self.audio = KaicongAudio(self.ip, user=self.user, pwd=self.pwd)
         self.audio.connect()
         gst.info("Connected audio")
コード例 #10
0
    def seek_end(self):
        event = gst.event_new_seek(1.0, gst.FORMAT_TIME,
            gst.SEEK_FLAG_FLUSH | gst.SEEK_FLAG_ACCURATE,
            gst.SEEK_TYPE_END, -1,
            gst.SEEK_TYPE_NONE, 0)

        res = self.pipeline.send_event(event)
        if res:
            gst.info("setting new stream time to 0")
        else:
            gst.error("seek to end failed")
コード例 #11
0
ファイル: odyo.py プロジェクト: davidlhoumaud/Odyo
 def play(self):
     gst.info("playing...")
     self.player.set_state(gst.STATE_PLAYING)
     #Start FadeIn
     if len(sys.argv) > 3:
         if float(sys.argv[3]) > 0:
             self.player.set_property('volume', 0)
             self.FadeIn(float(sys.argv[3]),1)
         else:
             self.player.set_property('volume', 1)
     else:
         self.player.set_property('volume', 1)
コード例 #12
0
 def stop(self):
     self.percentage = None
     self.text = None
     self.cursec = None
     self.duration = None
     self.togo = None
     self.artist_name  = None
     self.track_name = None
     self.numalbum = None
     self.status = "End"
     self.src.set_state(gst.STATE_NULL)
     gst.info("stopped player")
コード例 #13
0
ファイル: pyzm_player.py プロジェクト: rlrosa/pyzm-player
 def on_message(self, bus, message):
     t = message.type
     if t == gst.MESSAGE_ERROR:
         err, debug = message.parse_error()
         print "Error: %s" % err, debug
         self.stop()
     elif t == gst.MESSAGE_EOS:
         gst.info("File playback completed")
         ok,moved = self.cb_eos()
         if ok:
             gst.debug('eos callback completed, moved queue %d places' % moved)
         else:
             gst.warning('eos callback failed!')
コード例 #14
0
ファイル: odyo.py プロジェクト: davidlhoumaud/Odyo
 def stop(self):
     #FadeOut
     if len(sys.argv) > 3:
         if float(sys.argv[4]) > 0:
             self.FadeOut(float(sys.argv[4]),0)
         else:
             self.player.set_property('volume', 0)
     else:
         self.player.set_property('volume', 0)
     #End FadeOut
     gst.info("stopped")
     self.player.set_state(gst.STATE_NULL)
     self.playmode = False
コード例 #15
0
ファイル: odyo.py プロジェクト: davidlhoumaud/Odyo
    def seek(self, location):
        gst.debug("seeking to %r" % location)
        event = gst.event_new_seek(1.0, gst.FORMAT_TIME,
            gst.SEEK_FLAG_FLUSH | gst.SEEK_FLAG_ACCURATE,
            gst.SEEK_TYPE_SET, location,
            gst.SEEK_TYPE_NONE, 0)

        res = self.player.send_event(event)
        if res:
            gst.info("setting new stream time to 0")
            self.player.set_new_stream_time(0L)
        else:
            gst.error("seek to %r failed" % location)
コード例 #16
0
def main(args):

    dev = int(sys.argv[1])
    gobject.type_register(SomaAudioEventFilter)

    audioSrc = gst.element_factory_make('somaeventsource', 'SomaEventSource')
    #audioSrc = gst.element_factory_make('audiotestsrc', "test src")

    gst.info('About to create SomaAudioFilter')
    #somaAudioEventFilter = PyIdentity()
    somaAudioEventFilter = SomaAudioEventFilter()
    print "Created somaAudioEventFilter"
    somaAudioEventFilter.set_audio_src(dev)
    
    pipeline = gst.Pipeline()
    pipeline.add(audioSrc)
    pipeline.add(somaAudioEventFilter)

    finalSink = gst.element_factory_make("pulsesink")
    
    #finalSink = gst.element_factory_make("filesink")
    #finalSink.set_property("location", '/tmp/somaeventsourcetest.dat')

    pipeline.add(finalSink)
    ac = gst.element_factory_make("audioconvert")
    ars = gst.element_factory_make("audioresample")
    queue = gst.element_factory_make("queue")
    queue.set_property("max-size-buffers", 10000)
    pipeline.add(queue)
    pipeline.add(ac)
    pipeline.add(ars)

##     caps = gst.Caps("audio/x-raw-int,rate=44100")
##     filter = gst.element_factory_make("capsfilter", "filter")
##     filter.set_property("caps", caps)
##     pipeline.add(filter)
    
    gst.element_link_many(audioSrc, somaAudioEventFilter, queue,
                          ac, ars, finalSink)
    #gst.element_link_many(audioSrc,somaAudioEventFilter, ars, filter, finalSink)
    #gst.element_link_many(audioSrc,somaAudioEventFilter, queue, finalSink)
    #gst.element_link_many(audioSrc, finalSink)

    #gst.element_link_many(audioSrc,somaAudioEventFilter, finalSink)
    print "somaAudioFilter linked to finalSink"

    print "Pipeline setup, setting STATE to PLAYING"
    pipeline.set_state(gst.STATE_PLAYING)


    gobject.MainLoop().run()
コード例 #17
0
    def seek(self, location):
        """
        @param location: time to seek to, in nanoseconds
        """
        gst.debug("seeking to %r" % location)
        event = gst.event_new_seek(1.0, gst.FORMAT_TIME,
            gst.SEEK_FLAG_FLUSH | gst.SEEK_FLAG_ACCURATE,
            gst.SEEK_TYPE_SET, location,
            gst.SEEK_TYPE_NONE, 0)

        res = self.pipeline.send_event(event)
        if res:
            gst.info("setting new stream time to 0")
            # self.pipeline.set_start_time(0L)
        else:
            gst.error("seek to %r failed" % location)
コード例 #18
0
ファイル: GPlayer.py プロジェクト: kazutomi/xiphqt
    def fast_forward(self):
        """
            Here we will fast forward the stream for as many times
            as this is called
        """
        if self.rate < 8.0:
            self.rate = self.rate*2.0
            event = gst.event_new_seek(self.rate, gst.FORMAT_TIME,
                gst.SEEK_FLAG_FLUSH,
                gst.SEEK_TYPE_SET, self.query_position()[0],
                gst.SEEK_TYPE_NONE, 0)

            res = self.player.send_event(event)
            if res:
                gst.info("fast forwarding at rate: %f" % self.rate)
                self.player.set_new_stream_time(0L)
            else:
                gst.error("change rate to %f failed" % self.rate)
        return
コード例 #19
0
ファイル: GPlayer.py プロジェクト: kazutomi/xiphqt
    def slow_motion(self):
        """
            Here we will slow motion the stream for as many times
            as this is called
        """
        self.rate = self.rate/2.0
        event = gst.event_new_seek(self.rate, gst.FORMAT_TIME,
            gst.SEEK_FLAG_FLUSH,
            gst.SEEK_TYPE_SET, self.query_position()[0],
            gst.SEEK_TYPE_NONE, 0)

        res = self.player.send_event(event)
        if res:
            gst.info("slowing playback to rate: %f" % self.rate)
            self.player.set_new_stream_time(0L)
        else:
            gst.error("change rate to %f failed" % self.rate)

        return
コード例 #20
0
    def __init__(self):
        gst.Element.__init__(self)

        gst.info('creating srcpadpad')
        self.srcpad = gst.Pad(self._srcpadtemplate, "src")
        gst.info('adding srcpad to self')
        self.add_pad(self.srcpad)
        self.srcpad.set_getcaps_function(self.src_getcaps_function)
        self.srcpad.set_setcaps_function(self.src_setcaps_function)


        gst.info('creating sinkpad')
        self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
        gst.info('adding sinkpad to self')
        self.add_pad(self.sinkpad)
        self.sinkpad.set_getcaps_function(self.sink_getcaps_function)
        self.sinkpad.set_setcaps_function(self.sink_setcaps_function)

        gst.info('setting chain/event functions')
        self.sinkpad.set_chain_function(self.chainfunc)
        self.sinkpad.set_event_function(self.eventfunc)
コード例 #21
0
ファイル: inverseelement.py プロジェクト: alon/geekcon2012
    def __init__(self, fun=None):
        gst.Element.__init__(self)
        gst.info('creating sinkpad')
        self.fun = fun
        self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
        gst.info('adding sinkpad to self')
        self.add_pad(self.sinkpad)
        self.srcpad = gst.Pad(self._srcpadtemplate, "src")
        gst.info('adding srcpad to self')
        self.add_pad(self.srcpad)

        gst.info('setting chain/event functions')
        self.sinkpad.set_chain_function(self.chainfunc)
        self.sinkpad.set_event_function(self.eventfunc)
コード例 #22
0
    def play(self, track=None, activate_item=-1):
#        self.player.set_state(gst.STATE_NULL)
#        gst.info("stopped player")
        if self.status == "paused" and track == None:
            track = self.cur_playing
        self.increment_counter(self.artist_counter, track['artist_id'])
        self.increment_counter(self.album_counter, track['album_id'])
        self.increment_counter(self.track_counter, track['id'])
        if track['stream'] == "query":
            track['stream'] = self.pyjama.jamendo.stream(track['id'])
        if track['duration'] == 0:
            #GET FROM JAMENDO
            track['duration'] = 60*59
                
        self.last_played = self.cur_playing
        self.cur_playing = track
        
        if self.status != "paused":
            self.stop()

        try:
            self.set_location(track['stream'])
        except:
            print "error"
        gst.info("playing player")
        self.player.set_state(gst.STATE_PLAYING)
        self.playing = True
        self.status = "Playing"

        track['pos'] = activate_item

        ev = self.pyjama.Events
        ev.raise_event('nowplaying', track)
#        ev.raise_event('nowplaying', artist = track['artist_name'], album = track['album_name'], track = track['name'], icon = img)
        #self.pyjama.notification(_("Now playing"), "<b><i>%s</i></b>:\n%s" % (track['artist_name'], track['name']), icon = img, size =)
        
        if activate_item > -1:
            self.pyjama.setplaylist(activate_item)
コード例 #23
0
ファイル: GPlayer.py プロジェクト: kazutomi/xiphqt
    def play(self):
        """
            Change the stream state to playing or simply
            change its playing rate to normal rate
        """
        if self.rate != 1.0:
            self.rate = 1.0
            event = gst.event_new_seek(self.rate, gst.FORMAT_TIME,
                gst.SEEK_FLAG_FLUSH,
                gst.SEEK_TYPE_SET, self.query_position()[0],
                gst.SEEK_TYPE_NONE, 0)

            res = self.player.send_event(event)
            if res:
                gst.info("slowing playback to rate: %f" % self.rate)
                self.player.set_new_stream_time(0L)
            else:
                gst.error("change rate to %f failed" % self.rate)           
        else:
            gst.info("playing player")
            self.player.set_state(gst.STATE_PLAYING)
            self.playing = True
        return
コード例 #24
0
    def chainfunc(self, pad, buffer):
        """
        This is the primary function that takes in event buffers and emits
        audio buffers.
        
        """
        buffer_out = ""	
        nEvents = len(buffer)/12;  
        gst.info("somaEventFilter.chainfunc length of Buffer IN:" +  str(len(buffer)) + ' with nEvents:' + str(nEvents))

        if len(buffer) % 12 != 0:
            gst.warn( "Error: nEvents % 12 !=0")
            return ""

        for i in range(nEvents):
            buffer_out = buffer_out + (self.parseEvent( buffer[ (i*12) : (i*12)+12 ] ))

        buf = gst.Buffer(buffer_out)
        caps = self.srccaps 

        buf.set_caps(caps)
        gst.info("returning %d samples" % len(buffer))
        return  self.srcpad.push(buf)
コード例 #25
0
    def __init__(self):
        gst.Element.__init__(self)

        gst.info('creating srcpadpad')
        self.srcpad = gst.Pad(self._srcpadtemplate, "src")
        gst.info('adding srcpad to self')
        self.add_pad(self.srcpad)
        self.srcpad.set_getcaps_function(self.src_getcaps_function)
        self.srcpad.set_setcaps_function(self.src_setcaps_function)

        gst.info('creating sinkpad')
        self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
        gst.info('adding sinkpad to self')
        self.add_pad(self.sinkpad)
        self.sinkpad.set_getcaps_function(self.sink_getcaps_function)
        self.sinkpad.set_setcaps_function(self.sink_setcaps_function)

        gst.info('setting chain/event functions')
        self.sinkpad.set_chain_function(self.chainfunc)
        self.sinkpad.set_event_function(self.eventfunc)
        self.srccaps =  gst.caps_from_string('audio/x-raw-int,rate=32000,channels=1,endianness=1234,width=16,depth=16,signed=true')
        self.AUDIO_BCAST_CMD = 0x18;
        self.lastvalue = 0
コード例 #26
0
ファイル: pyzm_player.py プロジェクト: rlrosa/pyzm-player
    def run(self):
        # arg list: cb,src,port=555
        assert(len(self.args) == 3)
        self.threadID = 1
        self.cb       = self.args[0]
        self.src      = self.args[1]
        self.port     = self.args[2]
        self.context  = None
        self.server   = None
        self.name     = 'Listener'

        gst.debug('%s listener thread starting....' % self.src)
        if self.src == 'zmq':
            # zmq_init
            self.context = zmq.Context()
            self.server  = self.context.socket(zmq.REP)
            self.server.bind('tcp://*:%d' % self.port)
            print 'zmq listener running on port %d' % self.port
        # run loop
        while not self.stop_request.is_set():
            gst.info('Waiting for %s input...' % self.src)
            if(self.src == 'zmq'):
                msg = self.server.recv()
            else:
                msg = raw_input('Command:')
            gst.info('Rx: %s' % msg)
            ans = self.cb(msg)
            gst.debug('Callback exe completed')
            if(self.src == 'zmq'):
                self.server.send(ans)
                gst.debug('Answer sent to client: %s' % ans)
        # zmq_deinit
        if self.context != None:
            gst.debug('Cleaning up zmq')
            if self.server != None:
                self.server.close()
            self.context.term()
コード例 #27
0
ファイル: sinkelement.py プロジェクト: willman1990/ndnvideo
    def __init__(self):
        gst.Element.__init__(self)
        gst.info('creating sinkpad')
        self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
        gst.info('adding sinkpad to self')
        self.add_pad(self.sinkpad)

        gst.info('setting chain/event functions')
        self.sinkpad.set_chain_function(self.chainfunc)
        self.sinkpad.set_event_function(self.eventfunc)
コード例 #28
0
ファイル: gstvideo.py プロジェクト: poelzi/ledwallfoo
    def __init__(self, matrix):
        print("init")
        gst.BaseSink.__init__(self)
        self.matrix = matrix
        gst.info('creating sinkpad')
    #    self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
        gst.info('adding sinkpad to self')
        #self.add_pad(self.sinkpad)
        self.set_sync(True)

        gst.info('setting chain/event functions')
        #self.sinkpad.set_chain_function(self.chainfunc)
        self.sinkpad.set_event_function(self.eventfunc)
コード例 #29
0
ファイル: gstvideo.py プロジェクト: poelzi/ledwallfoo
    def __init__(self, matrix):
        print("init")
        gst.BaseSink.__init__(self)
        self.matrix = matrix
        gst.info('creating sinkpad')
        #    self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
        gst.info('adding sinkpad to self')
        #self.add_pad(self.sinkpad)
        self.set_sync(True)

        gst.info('setting chain/event functions')
        #self.sinkpad.set_chain_function(self.chainfunc)
        self.sinkpad.set_event_function(self.eventfunc)
コード例 #30
0
ファイル: lapse.py プロジェクト: dnlcrl/python_snippets
    def __init__(self):
        gst.Element.__init__(self)
        gst.info('creating pads')
        self.srcpad = gst.Pad(self._srcpadtemplate, "src")
        self.sinkpad = gst.Pad(self._sinkpadtemplate, "sink")
        gst.info('adding pads to self')
        self.add_pad(self.srcpad)
        self.add_pad(self.sinkpad)

        gst.info('setting chain/event functions')
        #self.srcpad.set_chain_function(self.src_chainfunc)
        #self.srcpad.set_event_function(self.src_eventfunc)

        self.sinkpad.set_chain_function(self.sink_chainfunc)
        self.sinkpad.set_event_function(self.sink_eventfunc)

        self.time_cb = None
        self.interval = 60
        self._calc_next()
コード例 #31
0
ファイル: remuxer.py プロジェクト: GStreamer/gst-python
 def play(self):
     gst.info("playing player")
     self.player.set_state(gst.STATE_PLAYING)
     self.playing = True
コード例 #32
0
ファイル: remuxer.py プロジェクト: GStreamer/gst-python
 def pause(self):
     gst.info("pausing player")
     self.player.set_state(gst.STATE_PAUSED)
     self.playing = False
コード例 #33
0
ファイル: remuxer.py プロジェクト: GStreamer/gst-python
 def stop(self):
     self.player.set_state(gst.STATE_NULL)
     gst.info("stopped player")
コード例 #34
0
 def play(self):
     self.playing = True
     gst.info("playing player")
     self.pipeline.set_state(gst.STATE_PLAYING)
コード例 #35
0
ファイル: gui.py プロジェクト: vliaskov/videocontrol
 def pause(self):
     gst.info("pausing _player0")
     self._pipeline.set_state(gst.STATE_PAUSED)
     self._is_playing = False
コード例 #36
0
    def __init__(self, matrix):
        gst.BaseSink.__init__(self)
        self.matrix = matrix
        self.set_sync(True)

        gst.info('setting chain/event functions')
コード例 #37
0
ファイル: gui.py プロジェクト: vliaskov/videocontrol
 def stop(self):
     self._pipeline.set_state(gst.STATE_NULL)
     gst.info("stopped _player0")
コード例 #38
0
ファイル: sinkelement.py プロジェクト: willman1990/ndnvideo
        self.sinkpad.set_chain_function(self.chainfunc)
        self.sinkpad.set_event_function(self.eventfunc)

    def chainfunc(self, pad, buffer):
        self.info("%s timestamp(buffer):%d" % (pad, buffer.timestamp))
        return gst.FLOW_OK

    def eventfunc(self, pad, event):
        self.info("%s event:%r" % (pad, event.type))
        return True


gobject.type_register(MySink)

#
# Code to test the MySink class
#

src = gst.element_factory_make('fakesrc')
gst.info('About to create MySink')
sink = MySink()

pipeline = gst.Pipeline()
pipeline.add(src, sink)

src.link(sink)

pipeline.set_state(gst.STATE_PLAYING)

gobject.MainLoop().run()
コード例 #39
0
 def stop(self):
     self.pipeline.set_state(gst.STATE_NULL)
     gst.info("stopped player")
     self.playing = False
コード例 #40
0
 def Stop(self):
     gst.info("stopping player")
     self._playbin.set_state(gst.STATE_READY)
     gst.info("stopped player")
コード例 #41
0
 def Pause(self):
     gst.info("pausing player")
     self._playbin.set_state(gst.STATE_PAUSED)
コード例 #42
0
 def Play(self):
     gst.info("playing player")
     self._playbin.set_state(gst.STATE_PLAYING)