try:

            os.makedirs(outDir)

        except OSError:

            pass

        img.save(outFilename)

        now = time.time()

        log.info("wrote %s delay of %.2fms, took %.2fms",

                  outFilename,

                  (now - self.lastTime) * 1000,

                  (now - t1) * 1000)

        self.updateRecordingTo(outDir)

        self.lastTime = now

gobject.type_register(VideoRecordSink)

class Main(object):

    def __init__(self):

        wtree = gtk.Builder()

        wtree.add_from_file(sibpath(__file__, "vidref.glade"))

        mainwin = wtree.get_object("MainWindow")

        mainwin.connect("destroy", gtk.main_quit)

        wtree.connect_signals(self)

        mainwin.set_size_request(920, 815)

        gtk.rc_parse("theme/marble-ice/gtk-2.0/gtkrc")

        self.recordingTo = wtree.get_object('recordingTo')

        self.musicScale = wtree.get_object("musicScale")

        self.musicScale.connect("value-changed", self.onMusicScaleValue)

        # tiny race here if onMusicScaleValue tries to use musicTime right away

        self.musicTime = MusicTime(onChange=self.onMusicTimeChange)

        self.ignoreScaleChanges = False

        # self.attachLog(wtree.get_object("lastLog")) # disabled due to crashing

        # wtree.get_object("replayPanel").show() # demo only

        rp = wtree.get_object("replayVbox")

        self.replayViews = ReplayViews(rp)

        mainwin.show_all()

        vid3 = wtree.get_object("vid3")

        self.liveVideoXid = vid3.window.xid

        vid3.props.width_request = 360

        vid3.props.height_request = 220

        wtree.get_object("frame1").props.height_request = 220

        gobject.timeout_add(1000 // framerate, self.updateLoop)

    def attachLog(self, textBuffer):

        """write log lines to this gtk buffer"""

        class ToBuffer(logging.Handler):

            def emit(self, record):

                textBuffer.set_text(record.getMessage())

        h = ToBuffer()

        h.setLevel(logging.INFO)

        log.addHandler(h)

    def updateLoop(self):

        position = self.musicTime.getLatest()

        try:

            with gtk.gdk.lock:

                self.replayViews.update(position)

        except:

            traceback.print_exc()

        return True

    def getInputs(self):

        return ['auto', 'dv', 'video0']

    def setInput(self, name):

        sourcePipe = {

            "auto": "autovideosrc name=src1",

            "testpattern" : "videotestsrc name=src1",

            "dv": "dv1394src name=src1 ! dvdemux ! dvdec",

            }[name]

        cam = (sourcePipe + " ! "

              "videorate ! video/x-raw-yuv,framerate=%s/1 ! "

              "videoscale ! video/x-raw-yuv,width=640,height=480;video/x-raw-rgb,width=320,height=240 ! "

              "videocrop left=160 top=180 right=120 bottom=80 ! "

              "queue name=vid" % framerate)

        self.pipeline = gst.parse_launch(cam)

        def makeElem(t, n=None):

            e = gst.element_factory_make(t, n)

            self.pipeline.add(e)

            return e

        sink = makeElem("xvimagesink")

        def setRec(t):

            # if you're selecting the text while gtk is updating it,

            # you can get a crash in xcb_io

            if getattr(self, '_lastRecText', None) == t:

                return

            with gtk.gdk.lock:

                self.recordingTo.set_text(t)

            self._lastRecText = t

        recSink = VideoRecordSink(self.musicTime, setRec)

        self.pipeline.add(recSink)

        tee = makeElem("tee")

        caps = makeElem("capsfilter")

        caps.set_property('caps', gst.caps_from_string('video/x-raw-rgb'))

        gst.element_link_many(self.pipeline.get_by_name("vid"), tee, sink)

        gst.element_link_many(tee, makeElem("ffmpegcolorspace"), caps, recSink)

        sink.set_xwindow_id(self.liveVideoXid)

        self.pipeline.set_state(gst.STATE_PLAYING)        

    def on_liveVideoEnabled_toggled(self, widget):

        if widget.get_active():

            self.pipeline.set_state(gst.STATE_PLAYING)

            # this is an attempt to bring the dv1394 source back, but

            # it doesn't work right.

            self.pipeline.get_by_name("src1").seek_simple(

                gst.FORMAT_TIME, gst.SEEK_FLAG_FLUSH, 0 * gst.SECOND)

        else:

            self.pipeline.set_state(gst.STATE_READY)

    def on_liveFrameRate_value_changed(self, widget):