path: root/DesktopGrab.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# 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 St, Fifth Floor, Boston, MA  02110-1301  USA

'''
Model:
    gst-launch-0.10 ximagesrc startx=0 endx=1200 starty=0 endy=900 ! \
    ffmpegcolorspace ! \
    videoscale ! \
    video/x-raw-yuv,width=320,height=240 ! \
    theoraenc ! \
    queue max-size-buffers=10000 max-size-bytes=0 max-size-time=0 ! \
    mux. oggmux name=mux \
    alsasrc ! \
    audio/x-raw-int,width=16,depth=16,rate=8000,channels=1 ! \
    audioconvert ! \
    vorbisenc ! \
    queue max-size-buffers=10000 max-size-bytes=0 max-size-time=0 ! \
    mux. mux. ! \
    filesink location=file.ogg
'''

import sys
import os
import gtk
import gobject
import gst
import pygst
import time
import datetime

gobject.threads_init()
gtk.gdk.threads_init()

class DesktopGrab(gtk.Widget):
    """Simple Grabador de Escritorio, Versión 2.0

    def set_audio_enabled(self, valor)
        Habilita/deshabilita el audio en la grabación.

    set_video_quality(self, resolucion)
        Configura calidad de video final.

    def record(self, location_path)
        Graba.

    def stop(self)
        Detiene la grabación."""

    __gsignals__ = {
        "update":(gobject.SIGNAL_RUN_FIRST,
        gobject.TYPE_NONE, (gobject.TYPE_STRING,))}

    def __init__(self):

        gtk.Widget.__init__(self)

        self.resolution = "video/x-raw-yuv,width=640,height=480" # 800x600 640x480 320x240

        self.pipeline = None
        self.update = None
        self.file_path = None
        self.enabled_sound = True
        self.info = None

        # Video
        self.ximagesrc = None
        self.ffmpegcolorspace = None
        self.videoscale = None
        self.video_filter = None
        self.theoraenc = None
        self.queue_video = None

        # Sound
        self.alsasrc = None
        self.sound_filter = None
        self.audioconvert = None
        self.vorbisenc = None
        self.queue_sound = None
        self.oggmux = None
        self.file = None
        self.bus = None

        self.x = 0
        self.y = 0
        self.width = int(gtk.gdk.screen_width())
        self.height = int(gtk.gdk.screen_height())

    def set_pipeline(self):
        """Crea el pipe para grabar desde x y autoaudio."""

        if self.pipeline:
            del(self.pipeline)
            self.pipeline = None

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

        # Video
        self.ximagesrc = gst.element_factory_make('ximagesrc', "x11")
        self.ximagesrc.set_property('startx', self.x)
        self.ximagesrc.set_property('endx', self.width)
        self.ximagesrc.set_property('starty', self.y)
        self.ximagesrc.set_property('endy', self.height)
        self.ffmpegcolorspace = gst.element_factory_make('ffmpegcolorspace', "ffmpegcolorspace")
        self.videoscale = gst.element_factory_make("videoscale", "videoscale")
        self.video_filter = gst.element_factory_make("capsfilter", "video_filter")
        video_caps = gst.Caps(self.resolution)
        self.video_filter.set_property("caps", video_caps)
        self.theoraenc = gst.element_factory_make('theoraenc', 'theoraenc')
        self.queue_video = gst.element_factory_make('queue', "queue_video")
        self.queue_video.set_property('max-size-buffers', 10000)
        self.queue_video.set_property('max-size-bytes', 0)
        self.queue_video.set_property('max-size-time', 0)

        # Sound
        self.alsasrc = gst.element_factory_make('alsasrc', "alsasrc")
        sound_caps = gst.Caps("audio/x-raw-int,width=16,depth=16,rate=8000,channels=1")
        self.sound_filter = gst.element_factory_make("capsfilter", "sound_filter")
        self.sound_filter.set_property("caps", sound_caps)
        self.audioconvert = gst.element_factory_make('audioconvert', "audioconvert")
        self.vorbisenc = gst.element_factory_make('vorbisenc', "vorbisenc")
        self.queue_sound = gst.element_factory_make('queue', "queue_sound")
        self.queue_sound.set_property('max-size-buffers', 10000)
        self.queue_sound.set_property('max-size-bytes', 0)
        self.queue_sound.set_property('max-size-time', 0)

        self.oggmux = gst.element_factory_make('oggmux', "oggmux")

        self.file = gst.element_factory_make('filesink', "file")
        self.file.set_property("location", self.file_path)

        if self.enabled_sound:
            self.add_todos()
            self.link_todos()
        else:
            self.add_solo_video()
            self.link_solo_video()

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

    def link_solo_video(self):
        """Linkea solo los elementos de video y archivo, no de audio."""

        gst.element_link_many(
            self.ximagesrc,
            self.ffmpegcolorspace,
            self.videoscale,
            self.video_filter,
            self.theoraenc,
            self.queue_video,
            self.oggmux,
            self.file)

    def link_todos(self):
        """Linkea todos los elementos del pipe, de audio, video y archivo."""

        gst.element_link_many(
            self.ximagesrc,
            self.ffmpegcolorspace,
            self.videoscale,
            self.video_filter,
            self.theoraenc,
            self.queue_video,
            self.oggmux)

        gst.element_link_many(
            self.alsasrc,
            self.sound_filter,
            self.audioconvert,
            self.vorbisenc,
            self.queue_sound,
            self.oggmux)

        gst.element_link_many(
            self.oggmux,
            self.file)

    def add_todos(self):
        """Agrega al pipe todos los elementos, de audio y video."""

        self.pipeline.add(
            self.ximagesrc,
            self.ffmpegcolorspace,
            self.videoscale,
            self.video_filter,
            self.theoraenc,
            self.queue_video,
            self.alsasrc,
            self.sound_filter,
            self.audioconvert,
            self.vorbisenc,
            self.queue_sound,
            self.oggmux,
            self.file)

    def add_solo_video(self):
        """Agrega al pipe solo los elementos de video pero no de adio."""

        self.pipeline.add(
            self.ximagesrc,
            self.ffmpegcolorspace,
            self.videoscale,
            self.video_filter,
            self.theoraenc,
            self.queue_video,
            self.oggmux,
            self.file)

    def set_audio_enabled(self, valor):
        """Habilita y desabilita el audio en la grabación."""

        self.stop()
        self.enabled_sound = valor

    def set_video_quality(self, resolution):
        """Configura la calidad de grabación de video."""

        self.stop()

        w, h = resolution
        self.resolution = "video/x-raw-yuv,width=%i,height=%i" % (w,h)

    def on_sync_message(self, bus, message):
        """Captura mensajes en el bus."""

        if message.structure is None: return

    def on_message(self, bus, message):
        """Captura mensajes en el bus."""

        if message.type == gst.MESSAGE_ERROR:
            err, debug = message.parse_error()
            # "ERROR ON_MESSAGE: ", err, debug
            self.pipeline.set_state(gst.STATE_NULL)

    def record(self, location_path):
        """Comienza a Grabar."""

        self.new_handle(False)

        if self.pipeline:
            self.pipeline.set_state(gst.STATE_PAUSED)
            self.pipeline.set_state(gst.STATE_NULL)

        """
        dat = datetime.date.today()
        tim = time.strftime("%H-%M-%S")
        self.file_path = os.path.join(location_path,"%s-%s.ogg" % (dat, tim))
        """
        self.file_path = location_path

        self.set_pipeline()

        self.pipeline.set_state(gst.STATE_PLAYING)

        self.new_handle(True)

    def stop(self):
        """Detiene la grabación."""

        self.new_handle(False)

        if self.pipeline:
            self.pipeline.set_state(gst.STATE_PAUSED)
            self.pipeline.set_state(gst.STATE_NULL)

        self.estado = None

    def new_handle(self, reset):
        """Reinicia o mata el actualizador."""

        if self.update:
            gobject.source_remove(self.update)
            self.update = None

        if reset:
            self.update = gobject.timeout_add(1000, self.handle)

    def handle(self):
        """Envía información periódicamente."""

        if os.path.exists(self.file_path):
            tamanio = int(os.path.getsize(self.file_path)/1024)
            info = "Record: %s - %s Kb." % (str(self.file_path), str(tamanio))

            if self.info != info:
                self.info = info
                self.emit('update', self.info)
                #print self.info

        return True

if __name__=="__main__":

    #default_location = os.path.dirname(__file__)
    grabador = DesktopGrab()
    grabador.set_audio_enabled(True)
    if os.path.exists('/home/flavio'):
        path = '/home/flavio'
    else:
        path = '/home/olpc'
    grabador.record(path)
    gtk.main()