path: root/glive.py

#Copyright (c) 2008, Media Modifications Ltd.

#Permission is hereby granted, free of charge, to any person obtaining a copy
#of this software and associated documentation files (the "Software"), to deal
#in the Software without restriction, including without limitation the rights
#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
#copies of the Software, and to permit persons to whom the Software is
#furnished to do so, subject to the following conditions:

#The above copyright notice and this permission notice shall be included in
#all copies or substantial portions of the Software.

#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
#THE SOFTWARE.


import os
import gtk
import pygtk
pygtk.require('2.0')
import sys
import gst
import gst.interfaces
import pygst
pygst.require('0.10')
import time
import threading
import gobject
gobject.threads_init()

from sugar.activity.activity import get_bundle_path
import logging

from instance import Instance
from constants import Constants
import record
import utils
import ui

logger = logging.getLogger('record:glive.py')

OGG_TRAITS = {
        0: { 'width': 160, 'height': 120, 'quality': 16 },
        1: { 'width': 400, 'height': 300, 'quality': 16 } }

THUMB_STUB = gtk.gdk.pixbuf_new_from_file(
    os.path.join(get_bundle_path(), 'gfx', 'stub.png'))

def _does_camera_present():
    v4l2src = gst.element_factory_make('v4l2src')
    if v4l2src.props.device_name is None:
        return False, False

    # Figure out if we can place a framerate limit on the v4l2 element, which
    # in theory will make it all the way down to the hardware.
    # ideally, we should be able to do this by checking caps. However, I can't
    # find a way to do this (at this time, XO-1 cafe camera driver doesn't
    # support framerate changes, but gstreamer caps suggest otherwise)
    pipeline = gst.Pipeline()
    caps = gst.Caps("video/x-raw-yuv,framerate=10/1")
    fsink = gst.element_factory_make("fakesink")
    pipeline.add(v4l2src, fsink)
    v4l2src.link(fsink, caps)
    can_limit_framerate = pipeline.set_state(gst.STATE_PAUSED) != gst.STATE_CHANGE_FAILURE
    pipeline.set_state(gst.STATE_NULL)
    return True, can_limit_framerate

camera_presents, can_limit_framerate = _does_camera_present()

class Glive:
    def __init__(self, pca):
        self.window = None
        self.ca = pca
        self._eos_cb = None

        self.playing = False
        self.picExposureOpen = False

        self.AUDIO_TRANSCODE_ID = 0
        self.TRANSCODE_ID = 0
        self.VIDEO_TRANSCODE_ID = 0

        self.PHOTO_MODE_PHOTO = 0
        self.PHOTO_MODE_AUDIO = 1

        self.TRANSCODE_UPDATE_INTERVAL = 200


        self.VIDEO_WIDTH_SMALL = 160
        self.VIDEO_HEIGHT_SMALL = 120
        self.VIDEO_FRAMERATE_SMALL = 10

        self.VIDEO_WIDTH_LARGE = 200
        self.VIDEO_HEIGHT_LARGE = 150
        self.VIDEO_FRAMERATE_SMALL = 10

        self.pipeline = gst.Pipeline("my-pipeline")
        self.createPhotoBin()
        self.createAudioBin()
        self.createVideoBin()
        self.createPipeline()

        self.thumbPipes = []
        self.muxPipes = []

        bus = self.pipeline.get_bus()
        bus.enable_sync_message_emission()
        bus.add_signal_watch()
        self.SYNC_ID = bus.connect('sync-message::element', self._onSyncMessageCb)
        self.MESSAGE_ID = bus.connect('message', self._onMessageCb)

    def createPhotoBin ( self ):
        queue = gst.element_factory_make("queue", "pbqueue")
        queue.set_property("leaky", True)
        queue.set_property("max-size-buffers", 1)

        colorspace = gst.element_factory_make("ffmpegcolorspace", "pbcolorspace")
        jpeg = gst.element_factory_make("jpegenc", "pbjpeg")

        sink = gst.element_factory_make("fakesink", "pbsink")
        self.HANDOFF_ID = sink.connect("handoff", self.copyPic)
        sink.set_property("signal-handoffs", True)

        self.photobin = gst.Bin("photobin")
        self.photobin.add(queue, colorspace, jpeg, sink)

        gst.element_link_many(queue, colorspace, jpeg, sink)

        pad = queue.get_static_pad("sink")
        self.photobin.add_pad(gst.GhostPad("sink", pad))

    def createAudioBin ( self ):
        src = gst.element_factory_make("alsasrc", "absrc")

        # attempt to use direct access to the 0,0 device, solving some A/V
        # sync issues
        src.set_property("device", "plughw:0,0")
        hwdev_available = src.set_state(gst.STATE_PAUSED) != gst.STATE_CHANGE_FAILURE
        src.set_state(gst.STATE_NULL)
        if not hwdev_available:
            src.set_property("device", "default")

        srccaps = gst.Caps("audio/x-raw-int,rate=16000,channels=1,depth=16")

        # guarantee perfect stream, important for A/V sync
        rate = gst.element_factory_make("audiorate")

        # without a buffer here, gstreamer struggles at the start of the
        # recording and then the A/V sync is bad for the whole video
        # (possibly a gstreamer/ALSA bug -- even if it gets caught up, it
        # should be able to resync without problem)
        queue = gst.element_factory_make("queue", "audioqueue")
        queue.set_property("leaky", True) # prefer fresh data
        queue.set_property("max-size-time", 5000000000) # 5 seconds
        queue.set_property("max-size-buffers", 500)
        queue.connect("overrun", self.log_queue_overrun)

        enc = gst.element_factory_make("wavenc", "abenc")

        sink = gst.element_factory_make("filesink", "absink")
        sink.set_property("location", os.path.join(Instance.instancePath, "output.wav"))

        self.audiobin = gst.Bin("audiobin")
        self.audiobin.add(src, rate, queue, enc, sink)

        src.link(rate, srccaps)
        gst.element_link_many(rate, queue, enc, sink)

    def createVideoBin ( self ):
        queue = gst.element_factory_make("queue", "videoqueue")
        queue.set_property("max-size-time", 5000000000) # 5 seconds
        queue.set_property("max-size-bytes", 33554432) # 32mb
        queue.connect("overrun", self.log_queue_overrun)

        scale = gst.element_factory_make("videoscale", "vbscale")

        scalecapsfilter = gst.element_factory_make("capsfilter", "scalecaps")

        scalecaps = gst.Caps('video/x-raw-yuv,width='+str(self.VIDEO_WIDTH_SMALL)+',height='+str(self.VIDEO_HEIGHT_SMALL))
        scalecapsfilter.set_property("caps", scalecaps)

        colorspace = gst.element_factory_make("ffmpegcolorspace", "vbcolorspace")

        enc = gst.element_factory_make("theoraenc", "vbenc")
        enc.set_property("quality", 16)

        mux = gst.element_factory_make("oggmux", "vbmux")

        sink = gst.element_factory_make("filesink", "vbfile")
        sink.set_property("location", os.path.join(Instance.instancePath, "output.ogg"))

        self.videobin = gst.Bin("videobin")
        self.videobin.add(queue, scale, scalecapsfilter, colorspace, enc, mux, sink)

        queue.link(scale)
        scale.link_pads(None, scalecapsfilter, "sink")
        scalecapsfilter.link_pads("src", colorspace, None)
        gst.element_link_many(colorspace, enc, mux, sink)

        pad = queue.get_static_pad("sink")
        self.videobin.add_pad(gst.GhostPad("sink", pad))

    def cfgVideoBin (self, quality, width, height):
        vbenc = self.videobin.get_by_name("vbenc")
        vbenc.set_property("quality", 16)
        scaps = self.videobin.get_by_name("scalecaps")
        scaps.set_property("caps", gst.Caps("video/x-raw-yuv,width=%d,height=%d" % (width, height)))

    def createPipeline ( self ):
        src = gst.element_factory_make("v4l2src", "camsrc")
        try:
            # old gst-plugins-good does not have this property
            src.set_property("queue-size", 2)
        except:
            pass

        # if possible, it is important to place the framerate limit directly
        # on the v4l2src so that it gets communicated all the way down to the
        # camera level
        if can_limit_framerate:
            srccaps = gst.Caps('video/x-raw-yuv,framerate='+str(self.VIDEO_FRAMERATE_SMALL)+'/1')
        else:
            srccaps = gst.Caps('video/x-raw-yuv')

        # we attempt to limit the framerate on the v4l2src directly, but we
        # can't trust this: perhaps we are falling behind in our capture,
        # or maybe the kernel driver doesn't provide the exact framerate.
        # the videorate element guarantees a perfect framerate and is important
        # for A/V sync because OGG does not store timestamps, it just stores
        # the FPS value.
        rate = gst.element_factory_make("videorate")
        ratecaps = gst.Caps('video/x-raw-yuv,framerate='+str(self.VIDEO_FRAMERATE_SMALL)+'/1')

        tee = gst.element_factory_make("tee", "tee")
        queue = gst.element_factory_make("queue", "dispqueue")

        # prefer fresh frames
        queue.set_property("leaky", True)
        queue.set_property("max-size-buffers", 2)

        self.pipeline.add(src, rate, tee, queue)
        src.link(rate, srccaps)
        rate.link(tee, ratecaps)
        tee.link(queue)

        xvsink = gst.element_factory_make("xvimagesink", "xvsink")
        xv_available = xvsink.set_state(gst.STATE_PAUSED) != gst.STATE_CHANGE_FAILURE
        xvsink.set_state(gst.STATE_NULL)

        if xv_available:
            # http://thread.gmane.org/gmane.comp.video.gstreamer.devel/29644
            xvsink.set_property("sync", False)

            self.pipeline.add(xvsink)
            queue.link(xvsink)
        else:
            cspace = gst.element_factory_make("ffmpegcolorspace")
            xsink = gst.element_factory_make("ximagesink")

            # http://thread.gmane.org/gmane.comp.video.gstreamer.devel/29644
            xsink.set_property("sync", False)

            self.pipeline.add(cspace, xsink)
            gst.element_link_many(queue, cspace, xsink)

    def log_queue_overrun(self, queue):
        cbuffers = queue.get_property("current-level-buffers")
        cbytes = queue.get_property("current-level-bytes")
        ctime = queue.get_property("current-level-time")
        logger.error("Buffer overrun in %s (%d buffers, %d bytes, %d time)"
            % (queue.get_name(), cbuffers, cbytes, ctime))
 
    def thumbPipe(self):
        return self.thumbPipes[ len(self.thumbPipes)-1 ]


    def thumbEl(self, name):
        return self.thumbPipe().get_by_name(name)


    def muxPipe(self):
        return self.muxPipes[ len(self.muxPipes)-1 ]


    def muxEl(self, name):
        return self.muxPipe().get_by_name(name)


    def play(self):
        if not camera_presents:
            return

        self.pipeline.set_state(gst.STATE_PLAYING)
        self.playing = True

    def pause(self):
        self.pipeline.set_state(gst.STATE_PAUSED)
        self.playing = False


    def stop(self):
        self.pipeline.set_state(gst.STATE_NULL)
        self.playing = False

    def is_playing(self):
        return self.playing

    def idlePlayElement(self, element):
        element.set_state(gst.STATE_PLAYING)
        return False

    def stopRecordingAudio( self ):
        # We should be able to simply pause and remove the audiobin, but
        # this seems to cause a gstreamer segfault. So we stop the whole
        # pipeline while manipulating it.
        # http://dev.laptop.org/ticket/10183
        self.pipeline.set_state(gst.STATE_NULL)
        self.pipeline.remove(self.audiobin)
        self.pipeline.set_state(gst.STATE_PLAYING)
        gobject.idle_add( self.stoppedRecordingAudio )


    def stoppedRecordingVideo(self):
        if ( len(self.thumbPipes) > 0 ):
            thumbline = self.thumbPipes[len(self.thumbPipes)-1]
            thumbline.get_by_name('thumbFakesink').disconnect(self.THUMB_HANDOFF_ID)

        oggFilepath = os.path.join(Instance.instancePath, "output.ogg") #ogv
        if (not os.path.exists(oggFilepath)):
            self.record = False
            self.ca.m.cannotSaveVideo()
            self.ca.m.stoppedRecordingVideo()
            return
        oggSize = os.path.getsize(oggFilepath)
        if (oggSize <= 0):
            self.record = False
            self.ca.m.cannotSaveVideo()
            self.ca.m.stoppedRecordingVideo()
            return

        line = 'filesrc location=' + str(oggFilepath) + ' name=thumbFilesrc ! oggdemux name=thumbOggdemux ! theoradec name=thumbTheoradec ! tee name=thumbTee ! queue name=thumbQueue ! ffmpegcolorspace name=thumbFfmpegcolorspace ! jpegenc name=thumbJPegenc ! fakesink name=thumbFakesink'
        thumbline = gst.parse_launch(line)
        thumbQueue = thumbline.get_by_name('thumbQueue')
        thumbQueue.set_property("leaky", True)
        thumbQueue.set_property("max-size-buffers", 1)
        thumbTee = thumbline.get_by_name('thumbTee')
        thumbFakesink = thumbline.get_by_name('thumbFakesink')
        self.THUMB_HANDOFF_ID = thumbFakesink.connect("handoff", self.copyThumbPic)
        thumbFakesink.set_property("signal-handoffs", True)
        self.thumbPipes.append(thumbline)
        self.thumbExposureOpen = True
        gobject.idle_add( self.idlePlayElement, thumbline )


    def stoppedRecordingAudio( self ):
        record.Record.log.debug("stoppedRecordingAudio")
        if (self.audioPixbuf != None):
            audioFilepath = os.path.join(Instance.instancePath, "output.wav")#self.el("audioFilesink").get_property("location")
            if (not os.path.exists(audioFilepath)):
                self.record = False
                self.ca.m.cannotSaveVideo()
                return
            wavSize = os.path.getsize(audioFilepath)
            if (wavSize <= 0):
                self.record = False
                self.ca.m.cannotSaveVideo()
                return

            self.ca.ui.setPostProcessPixBuf(self.audioPixbuf)

            line = 'filesrc location=' + str(audioFilepath) + ' name=audioFilesrc ! wavparse name=audioWavparse ! audioconvert name=audioAudioconvert ! vorbisenc name=audioVorbisenc ! oggmux name=audioOggmux ! filesink name=audioFilesink'
            audioline = gst.parse_launch(line)

            taglist = self.getTags(Constants.TYPE_AUDIO)
            base64AudioSnapshot = utils.getStringFromPixbuf(self.audioPixbuf)
            taglist[gst.TAG_EXTENDED_COMMENT] = "coverart="+str(base64AudioSnapshot)
            vorbisEnc = audioline.get_by_name('audioVorbisenc')
            vorbisEnc.merge_tags(taglist, gst.TAG_MERGE_REPLACE_ALL)

            audioFilesink = audioline.get_by_name('audioFilesink')
            audioOggFilepath = os.path.join(Instance.instancePath, "output.ogg")
            audioFilesink.set_property("location", audioOggFilepath )

            audioBus = audioline.get_bus()
            audioBus.add_signal_watch()
            self.AUDIO_TRANSCODE_ID = audioBus.connect('message', self._onMuxedAudioMessageCb, audioline)
            self.TRANSCODE_ID = gobject.timeout_add(self.TRANSCODE_UPDATE_INTERVAL, self._transcodeUpdateCb, audioline)
            gobject.idle_add( self.idlePlayElement, audioline )
        else:
            self.record = False
            self.ca.m.cannotSaveVideo()


    def getTags( self, type ):
        tl = gst.TagList()
        tl[gst.TAG_ARTIST] = str(Instance.nickName)
        tl[gst.TAG_COMMENT] = "olpc"
        #this is unfortunately, unreliable
        #record.Record.log.debug("self.ca.metadata['title']->" + str(self.ca.metadata['title']) )
        tl[gst.TAG_ALBUM] = "olpc" #self.ca.metadata['title']
        tl[gst.TAG_DATE] = utils.getDateString(int(time.time()))
        stringType = Constants.mediaTypes[type][Constants.keyIstr]
        tl[gst.TAG_TITLE] = Constants.istrBy % {"1":stringType, "2":str(Instance.nickName)}
        return tl

    def blockedCb(self, x, y, z):
        pass

    def _takePhoto(self):
        if self.picExposureOpen:
            return

        self.picExposureOpen = True
        pad = self.photobin.get_static_pad("sink")
        pad.set_blocked_async(True, self.blockedCb, None)
        self.pipeline.add(self.photobin)
        self.photobin.set_state(gst.STATE_PLAYING)
        self.pipeline.get_by_name("tee").link(self.photobin)
        pad.set_blocked_async(False, self.blockedCb, None)

    def takePhoto(self):
        if not camera_presents:
            return

        self.photoMode = self.PHOTO_MODE_PHOTO
        self._takePhoto()

    def copyPic(self, fsink, buffer, pad, user_data=None):
        if not self.picExposureOpen:
            return

        pad = self.photobin.get_static_pad("sink")
        pad.set_blocked_async(True, self.blockedCb, None)
        self.pipeline.get_by_name("tee").unlink(self.photobin)
        self.pipeline.remove(self.photobin)
        pad.set_blocked_async(False, self.blockedCb, None)

        self.picExposureOpen = False
        pic = gtk.gdk.pixbuf_loader_new_with_mime_type("image/jpeg")
        pic.write( buffer )
        pic.close()
        pixBuf = pic.get_pixbuf()
        del pic

        self.savePhoto( pixBuf )


    def savePhoto(self, pixbuf):
        if self.photoMode == self.PHOTO_MODE_AUDIO:
            self.audioPixbuf = pixbuf
        else:
            self.ca.m.savePhoto(pixbuf)


    def startRecordingVideo(self, quality):
        if not camera_presents:
            return

        self.record = True
        self.ogg_quality = quality
        self.cfgVideoBin (OGG_TRAITS[quality]['quality'],
            OGG_TRAITS[quality]['width'],
            OGG_TRAITS[quality]['height'])

        # If we use pad blocking and adjust the pipeline on-the-fly, the
        # resultant video has bad A/V sync :(
        # If we pause the pipeline while adjusting it, the A/V sync is better
        # but not perfect :(
        # so we stop the whole thing while reconfiguring to get the best results
        self.pipeline.set_state(gst.STATE_NULL)
        self.pipeline.add(self.videobin)
        self.pipeline.get_by_name("tee").link(self.videobin)
        self.pipeline.add(self.audiobin)
        self.pipeline.set_state(gst.STATE_PLAYING)

    def startRecordingAudio(self):
        self.audioPixbuf = None

        self.photoMode = self.PHOTO_MODE_AUDIO
        self._takePhoto()

        self.record = True

        # we should be able to add the audiobin on the fly, but unfortunately
        # this results in several seconds of silence being added at the start
        # of the recording. So we stop the whole pipeline while adjusting it.
        # SL#2040
        self.pipeline.set_state(gst.STATE_NULL)
        self.pipeline.add(self.audiobin)
        self.pipeline.set_state(gst.STATE_PLAYING)

    def stopRecordingVideo(self):
        if not camera_presents:
            return

        # We stop the pipeline while we are adjusting the pipeline to stop
        # recording because if we do it on-the-fly, the following video live
        # feed to the screen becomes several seconds delayed. Weird!
        # FIXME: retest on F11
        self._eos_cb = self.stopRecordingVideoEOS
        self.pipeline.get_by_name('camsrc').send_event(gst.event_new_eos())
        self.audiobin.get_by_name('absrc').send_event(gst.event_new_eos())

    def stopRecordingVideoEOS(self):
        self.pipeline.set_state(gst.STATE_NULL)
        self.pipeline.get_by_name("tee").unlink(self.videobin)
        self.pipeline.remove(self.videobin)
        self.pipeline.remove(self.audiobin)
        self.pipeline.set_state(gst.STATE_PLAYING)
        gobject.idle_add( self.stoppedRecordingVideo )


    def copyThumbPic(self, fsink, buffer, pad, user_data=None):
        if not self.thumbExposureOpen:
            return

        self.thumbExposureOpen = False
        pic = gtk.gdk.pixbuf_loader_new_with_mime_type("image/jpeg")
        pic.write(buffer)
        pic.close()
        self.thumbBuf = pic.get_pixbuf()
        del pic
        self.thumbEl('thumbTee').unlink(self.thumbEl('thumbQueue'))

        oggFilepath = os.path.join(Instance.instancePath, "output.ogg") #ogv
        self.ca.ui.setPostProcessPixBuf(self.thumbBuf)

        wavFilepath = os.path.join(Instance.instancePath, "output.wav")
        muxFilepath = os.path.join(Instance.instancePath, "mux.ogg") #ogv

        muxline = gst.parse_launch('filesrc location=' + str(oggFilepath) + ' name=muxVideoFilesrc ! oggdemux name=muxOggdemux ! theoraparse ! oggmux name=muxOggmux ! filesink location=' + str(muxFilepath) + ' name=muxFilesink filesrc location=' + str(wavFilepath) + ' name=muxAudioFilesrc ! wavparse name=muxWavparse ! audioconvert name=muxAudioconvert ! vorbisenc name=muxVorbisenc ! muxOggmux.')
        taglist = self.getTags(Constants.TYPE_VIDEO)
        vorbisEnc = muxline.get_by_name('muxVorbisenc')
        vorbisEnc.merge_tags(taglist, gst.TAG_MERGE_REPLACE_ALL)

        muxBus = muxline.get_bus()
        muxBus.add_signal_watch()
        self.VIDEO_TRANSCODE_ID = muxBus.connect('message', self._onMuxedVideoMessageCb, muxline)
        self.muxPipes.append(muxline)
        #add a listener here to monitor % of transcoding...
        self.TRANSCODE_ID = gobject.timeout_add(self.TRANSCODE_UPDATE_INTERVAL, self._transcodeUpdateCb, muxline)
        muxline.set_state(gst.STATE_PLAYING)

    def _transcodeUpdateCb( self, pipe ):
        position, duration = self.queryPosition( pipe )
        if position != gst.CLOCK_TIME_NONE:
            value = position * 100.0 / duration
            value = value/100.0
            self.ca.ui.progressWindow.updateProgress(value, Constants.istrSaving)
        return True


    def queryPosition( self, pipe ):
        try:
            position, format = pipe.query_position(gst.FORMAT_TIME)
        except:
            position = gst.CLOCK_TIME_NONE

        try:
            duration, format = pipe.query_duration(gst.FORMAT_TIME)
        except:
            duration = gst.CLOCK_TIME_NONE

        return (position, duration)


    def _onMuxedVideoMessageCb(self, bus, message, pipe):
        t = message.type
        if (t == gst.MESSAGE_EOS):
            self.record = False
            gobject.source_remove(self.VIDEO_TRANSCODE_ID)
            self.VIDEO_TRANSCODE_ID = 0
            gobject.source_remove(self.TRANSCODE_ID)
            self.TRANSCODE_ID = 0
            pipe.set_state(gst.STATE_NULL)
            pipe.get_bus().remove_signal_watch()
            pipe.get_bus().disable_sync_message_emission()

            wavFilepath = os.path.join(Instance.instancePath, "output.wav")
            oggFilepath = os.path.join(Instance.instancePath, "output.ogg") #ogv
            muxFilepath = os.path.join(Instance.instancePath, "mux.ogg") #ogv
            os.remove( wavFilepath )
            os.remove( oggFilepath )
            ogg_w = OGG_TRAITS[self.ogg_quality]['width']
            ogg_h = OGG_TRAITS[self.ogg_quality]['height']
            self.ca.m.saveVideo(self.thumbBuf, str(muxFilepath), ogg_w, ogg_h)
            self.ca.m.stoppedRecordingVideo()
            return False
        else:
            return True


    def _onMuxedAudioMessageCb(self, bus, message, pipe):
        t = message.type
        if (t == gst.MESSAGE_EOS):
            record.Record.log.debug("audio gst.MESSAGE_EOS")
            self.record = False
            gobject.source_remove(self.AUDIO_TRANSCODE_ID)
            self.AUDIO_TRANSCODE_ID = 0
            gobject.source_remove(self.TRANSCODE_ID)
            self.TRANSCODE_ID = 0
            pipe.set_state(gst.STATE_NULL)
            pipe.get_bus().remove_signal_watch()
            pipe.get_bus().disable_sync_message_emission()

            wavFilepath = os.path.join(Instance.instancePath, "output.wav")
            oggFilepath = os.path.join(Instance.instancePath, "output.ogg")
            os.remove( wavFilepath )
            self.ca.m.saveAudio(oggFilepath, self.audioPixbuf)
            return False
        else:
            return True


    def _onSyncMessageCb(self, bus, message):
        if message.structure is None:
            return
        if message.structure.get_name() == 'prepare-xwindow-id':
            self.window.set_sink(message.src)
            message.src.set_property('force-aspect-ratio', True)


    def _onMessageCb(self, bus, message):
        t = message.type
        if t == gst.MESSAGE_EOS:
            if self._eos_cb:
                cb = self._eos_cb
                self._eos_cb = None
                cb()
        elif t == gst.MESSAGE_ERROR:
            #todo: if we come out of suspend/resume with errors, then get us back up and running...
            #todo: handle "No space left on the resource.gstfilesink.c"
            #err, debug = message.parse_error()
            pass

    def abandonMedia(self):
        self.stop()

        if (self.AUDIO_TRANSCODE_ID != 0):
            gobject.source_remove(self.AUDIO_TRANSCODE_ID)
            self.AUDIO_TRANSCODE_ID = 0
        if (self.TRANSCODE_ID != 0):
            gobject.source_remove(self.TRANSCODE_ID)
            self.TRANSCODE_ID = 0
        if (self.VIDEO_TRANSCODE_ID != 0):
            gobject.source_remove(self.VIDEO_TRANSCODE_ID)
            self.VIDEO_TRANSCODE_ID = 0

        wavFilepath = os.path.join(Instance.instancePath, "output.wav")
        if (os.path.exists(wavFilepath)):
            os.remove(wavFilepath)
        oggFilepath = os.path.join(Instance.instancePath, "output.ogg") #ogv
        if (os.path.exists(oggFilepath)):
            os.remove(oggFilepath)
        muxFilepath = os.path.join(Instance.instancePath, "mux.ogg") #ogv
        if (os.path.exists(muxFilepath)):
            os.remove(muxFilepath)


class LiveVideoWindow(gtk.Window):
    def __init__(self, bgd ):
        gtk.Window.__init__(self)

        self.imagesink = None
        self.glive = None

        self.modify_bg( gtk.STATE_NORMAL, bgd )
        self.modify_bg( gtk.STATE_INSENSITIVE, bgd )
        self.unset_flags(gtk.DOUBLE_BUFFERED)
        self.set_flags(gtk.APP_PAINTABLE)

    def set_glive(self, pglive):
        self.glive = pglive
        self.glive.window = self

    def set_sink(self, sink):
        if (self.imagesink != None):
            assert self.window.xid
            self.imagesink = None
            del self.imagesink

        self.imagesink = sink
        self.imagesink.set_xwindow_id(self.window.xid)