예제 #1
0
	def prepareGST(self, url):
		self.checked_video = False
		self.playing = False
		bin = gst.Bin('my-bin')
		self.textoverlay = gst.element_factory_make('textoverlay')
		bin.add(self.textoverlay)
		pad = self.textoverlay.get_pad("video_sink")
		ghostpad = gst.GhostPad("sink", pad)
		bin.add_pad(ghostpad)
		videosink = gst.gst_parse_bin_from_description("videobalance name=balance ! autovideosink", True)
		bin.add(videosink)
		gst.element_link_many(self.textoverlay, videosink)
		self.player = gst.element_factory_make("playbin2", "player")
		bus = self.player.get_bus()
		bus.add_signal_watch()
		bus.enable_sync_message_emission()
		bus.connect("sync-message::element", self.on_sync_message)
		bus.connect("message", self.on_message)
		self.player.set_property("video-sink", bin)
		self.player.set_property("uri", url)
		self.player.set_state(gst.STATE_PLAYING)
		self.mprunning = True
		gobject.idle_add(self.callback)
예제 #2
0
    def __init__(self):
        self.overlay_buffer = None
        self.overlay_text = "Foo Bar Baz 123"
        
        self.bus = dbus.SystemBus()
        #self.bus = dbus.SessionBus()
        #textsignal = self.bus.add_signal_receiver(self.overlay_text_changed, 'textchanged', 'com.example')
        textsignal = self.bus.add_signal_receiver(self.overlay_text_changed, dbus_interface = "com.example.TestService", signal_name = "HelloSignal")
    
    
        window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        window.set_title("Mpeg2-Player")
        window.set_default_size(500, 400)
        window.connect("destroy", gtk.main_quit, "WM destroy")
        vbox = gtk.VBox()
        window.add(vbox)
        hbox = gtk.HBox()
        vbox.pack_start(hbox, False)
        #self.entry = gtk.Entry()
        #hbox.add(self.entry)
        self.button = gtk.Button("Start")
        hbox.pack_start(self.button, False)
        self.button.connect("clicked", self.start_stop)
        self.movie_window = gtk.DrawingArea()
        vbox.add(self.movie_window)
        window.show_all()       

        # gst-launch v4l2src ! video/x-raw-yuv,format=\(fourcc\)YUY2,width=640,height=480 ! ffmpegcolorspace ! autovideosink


        #self.player = gst.parse_launch('videotestsrc name=source ! video/x-raw-yuv,format=(fourcc)AYUV ! videomixer name=mix ! ffmpegcolorspace ! autovideosink name=videosink')
        # PONDER: How to get the resolution from the videosink ?
        #self.player = gst.parse_launch('videotestsrc name=source ! video/x-raw-yuv,format=(fourcc)AYUV ! videomixer name=mix ! ffmpegcolorspace ! videoscale ! autovideosink name=videosink')
        #self.player = gst.parse_launch('videotestsrc name=source ! videoscale ! video/x-raw-yuv,format=(fourcc)AYUV ! videomixer name=mix ! ffmpegcolorspace !  autovideosink name=videosink')
        # This hardcoded resolution works.
        #self.player = gst.parse_launch('videotestsrc name=source ! video/x-raw-yuv,format=(fourcc)AYUV,width=500,height=400 ! videomixer name=mix ! ffmpegcolorspace !  autovideosink name=videosink')
        self.player = gst.parse_launch('videotestsrc name=source ! tee name=splitter')
        self.bin1 = gst.gst_parse_bin_from_description('queue ! video/x-raw-yuv,format=(fourcc)AYUV,width=500,height=400 ! videomixer name=mix ! ffmpegcolorspace !  autovideosink name=videosink', True)
        self.player.add(self.bin1)
        self.bin2 = gst.gst_parse_bin_from_description('queue ! video/x-raw-yuv,format=(fourcc)AYUV,width=500,height=400 ! videomixer name=mix ! ffmpegcolorspace !  tcpserversink name=videosink protocol=none port=3000', True)
        self.player.add(self.bin2)
        self.tee = self.player.get_by_name("splitter")
        self.tee.link(self.bin1)
        self.tee.link(self.bin2)

        # adapted from https://code.fluendo.com/flumotion/trac/browser/flumotion/trunk/flumotion/component/converters/overlay/overlay.py
        self.videomixer = self.bin1.get_by_name("mix")
        self.converter = self.bin1.get_by_name("conv")
        self.videomixer.get_pad('sink_0').connect('notify::caps', self._notify_caps_cb)
        self.sourceBin = gst.Bin()
        self.overlay = gst.element_factory_make('appsrc', 'overlay')
        self.overlay.set_property('do-timestamp', True)
        self.overlay.connect('need-data', self.push_buffer)
        self.sourceBin.add(self.overlay)
        self.alphacolor = gst.element_factory_make('alphacolor')
        self.sourceBin.add(self.alphacolor)
        self.overlay.link(self.alphacolor)
        self.sourceBin.add_pad(gst.GhostPad('src', self.alphacolor.get_pad('src')))
        self.sourceBin.set_locked_state(True)
        self.player.add(self.sourceBin)

        bus = self.player.get_bus()
        bus.add_signal_watch()
        bus.enable_sync_message_emission()
        bus.connect("message", self.on_message)
        bus.connect("sync-message::element", self.on_sync_message)

        self.start_stop(None)
예제 #3
0
파일: sltv.py 프로젝트: lucasa/landell-fgdp
    def play(self):

        self.emit("preplay")

        self.player = gst.Pipeline("player")

        self.queue_video = gst.element_factory_make("queue", "queue_video")
        self.player.add(self.queue_video)

        self.input_type = 0

        # Source selection

        self.source_pads = {}
        self.audio_pads = {}
        self.pip_pads = {}

        self.output_bins = {}
        type = 0
        source_number = 0
        pip_number = 0

        self.pip = PictureInPicture()

        self.player.add(self.pip)

        for row in self.sources.get_store():
            (name, source) = row
            element = source.create()
            self.player.add(element)

            if element.does_audio():
                if not self.input_type & MEDIA_AUDIO:

                    # The pipeline has audio sources, and this is the first
                    # audio source we add

                    if self.audio_source is None:
                        self.emit("error", "You need to select an audio source")
                        self.emit("stopped")
                        return
                    self.input_type |= MEDIA_AUDIO
                    self.input_selector = gst.element_factory_make(
                            "input-selector", "audio-selector"
                    )
                    self.player.add(self.input_selector)

                audiobin = audioinputbin.AudioInputBin(source)
                self.player.add(audiobin)

                element.audio_pad.link(audiobin.get_static_pad("sink"))
                self.audio_pads[name] = \
                        self.input_selector.get_request_pad("sink%d")
                audiobin.src_pad.link(self.audio_pads[name])

            if element.does_video():
                self.input_type |= MEDIA_VIDEO

                self.source_pads[name] = source_number
                source_number = source_number + 1

                # Thumbnail preview

                tee = gst.element_factory_make("tee", None)
                self.player.add(tee)
                element.video_pad.link(tee.sink_pads().next())

                thumbnail_queue = gst.element_factory_make("queue", None)
                self.player.add(thumbnail_queue)
                self.thumbnails[name] = Preview(self)
                self.player.add(self.thumbnails[name])

                thumbnail_err = gst.element_link_many(
                    tee, thumbnail_queue, self.thumbnails[name]
                )
                if thumbnail_err == False:
                    self.emit("error", "Error conecting thumbnail preview.")

                # Picture in Picture

                self.pip_pads[name] = pip_number
                pip_number = pip_number + 1

                main_queue = gst.element_factory_make("queue", None)
                self.player.add(main_queue)
                pip_queue = gst.element_factory_make("queue", None)
                self.player.add(pip_queue)

                tee.link(main_queue)
                tee.link(pip_queue)
                main_queue.src_pads().next().link(self.pip.get_request_pad_A())
                pip_queue.src_pads().next().link(self.pip.get_request_pad_B())

            if name == self.video_source:
                type |= element.get_type()
            if name == self.audio_source:
                type |= element.get_type()

        self.watermark = gst.element_factory_make(
                "cairoimageoverlay", "cairoimageoverlay"
        )
        self.player.add(self.watermark)

        self.colorspace = gst.element_factory_make(
                "ffmpegcolorspace", "colorspace-imageoverlay-videobalance"
        )
        self.player.add(self.colorspace)

        self.videobalance = gst.element_factory_make(
                "videobalance", "videobalance"
        )
        self.player.add(self.videobalance)
        if self.videobalance_contrast:
            self.videobalance.set_property(
                    "contrast", self.videobalance_contrast
            )
        if self.videobalance_brightness:
            self.videobalance.set_property(
                    "brightness", self.videobalance_brightness
            )
        if self.videobalance_hue:
            self.videobalance.set_property(
                    "hue", self.videobalance_hue
            )
        if self.videobalance_saturation:
            self.videobalance.set_property(
                    "saturation", self.videobalance_saturation
            )
            

        gst.element_link_many(
                self.pip, self.watermark, self.colorspace, self.videobalance, self.queue_video
        )

        self._switch_source()
        self._switch_pip()

        if self.pip_position:
            self.pip.set_property("position", self.pip_position)

        self.effect[MEDIA_VIDEO] = effect.video_effect.VideoEffect(
                self.effect_name[MEDIA_VIDEO]
        )
        self.player.add(self.effect[MEDIA_VIDEO])

        self.overlay = gst.element_factory_make("textoverlay", "overlay")
        self.overlay.set_property("font-desc", self.overlay_font)
        self.overlay.set_property("halign", self.halign)
        self.overlay.set_property("valign", self.valign)
        self.player.add(self.overlay)

        # microblog overlay
        self.microblog_overlay = gst.gst_parse_bin_from_description("ffmpegcolorspace name=_i ! rsvgoverlay name=rsvg ! queue name=_o", True)
        i = self.microblog_overlay.get_by_name("_i");
        o = self.microblog_overlay.get_by_name("_o");
        self.rsvg = self.microblog_overlay.get_by_name("rsvg");
        self.player.add(self.microblog_overlay)
        
        gst.element_link_many(
                self.queue_video, self.effect[MEDIA_VIDEO], self.overlay, i,
        )

        self.preview_tee = multeequeue.MulTeeQueue()
        self.player.add(self.preview_tee)

        self.microblog_overlay.link(self.preview_tee)

        if self.input_type & MEDIA_AUDIO:
            self.convert = gst.element_factory_make("audioconvert", "convert")
            self.player.add(self.convert)

            self.effect[MEDIA_AUDIO] = effect.audio_effect.AudioEffect(
                    self.effect_name[MEDIA_AUDIO]
            )
            self.player.add(self.effect[MEDIA_AUDIO])

            self.audio_tee = gst.element_factory_make("tee", "audio_tee")
            self.player.add(self.audio_tee)

            self.volume = volume.Volume()
            self.player.add(self.volume)

            self.level = gst.element_factory_make("level", "audio_level")
            self.level.set_property("message", True)
            self.player.add(self.level)

            gst.element_link_many(
                    self.input_selector, self.volume, self.level,
                    self.effect[MEDIA_AUDIO], self.convert, self.audio_tee
            )

            self.input_selector.set_property(
                    "active-pad", self.audio_pads[self.audio_source]
            )
        added_encoders = {}

        pip_width = 0
        pip_height = 0

        for row in self.outputs.get_store():
            (name, output) = row

            output_bin = outputbin.OutputBin(output)
            self.output_bins[name] = output_bin
            self.player.add(output_bin)

            encoder_name = output.get_config()["parent"]

            encoder_item = self.encoders.get_item(encoder_name)
            if encoder_item is None:
                self.emit("error", "Please, add an encoder.")
                break

            if added_encoders.has_key(encoder_name):
                tee = added_encoders[encoder_name]

                tee.link(output_bin)
            else:
                tee = gst.element_factory_make("tee", None)
                self.player.add(tee)

                converter_item = encoder_item.parent
                converter = converter_item.create()
                if converter_item.config["width"] > pip_width:
                    pip_width = converter_item.config["width"]
                if converter_item.config["height"] > pip_height:
                    pip_height = converter_item.config["height"]
                self.player.add(converter)

                encoder = encoder_item.factory.create(type)
                if encoder.vorbisenc:
                    self.metadata = metadata.Metadata(encoder.vorbisenc)
                    self.metadata.set_tags(self.taglist)
                encoder.config(encoder_item.config)
                self.player.add(encoder)

                added_encoders[encoder_name] = tee
                self.preview_tee.get_src_pad().link(
                        converter.sink_pads().next()
                )
                gst.element_link_many(
                        converter, encoder, tee, output_bin
                )

                if self.input_type & MEDIA_AUDIO:
                    audio_queue = gst.element_factory_make("queue", None)
                    self.player.add(audio_queue)

                    gst.element_link_many(self.audio_tee, audio_queue, encoder)

        if self.preview_enabled:
            self.preview = Preview(self)
            self.player.add(self.preview)
            self.preview_tee.get_src_pad().link(self.preview.sink_pads().next())

        if pip_width == 0:
            pip_width = 320
            pip_height = 240
        self.pip.set_property("width", int(pip_width))
        self.pip.set_property("height", int(pip_height))

        self.video_width = int(pip_width)
        self.video_height = int(pip_height)
        self._set_watermark(self.video_width, self.video_height)

        self.overlay.set_property("text", self.overlay_text)
        if self.volume_value is not None:
            self.volume.set_property("volume", self.volume_value)

        self.emit("pipeline-ready")

        bus = self.player.get_bus()
        bus.add_signal_watch()
        bus.enable_sync_message_emission()
        bus.connect("message", self.on_message)
        bus.connect("sync-message::element", self.on_sync_message)
        cr = self.player.set_state(gst.STATE_PLAYING)
        if cr == gst.STATE_CHANGE_SUCCESS:
            self.emit("playing")
        elif cr == gst.STATE_CHANGE_ASYNC:
            self.pending_state = gst.STATE_PLAYING