Merge lp:~jderose/novacut/renderer into lp:novacut

[Jason Gerard DeRose]

Yup, too tired to go into details!

=== added file 'create-demo-project.py'
--- create-demo-project.py	1970-01-01 00:00:00 +0000
+++ create-demo-project.py	2012-01-20 15:32:24 +0000
@@ -0,0 +1,73 @@
+#!/usr/bin/python3
+
+import json
+import time
+from microfiber import dmedia_env, Database, Conflict
+from novacut import schema
+from collections import OrderedDict
+
+docs = json.load(open('demo.json', 'r'))
+for doc in docs:
+    doc['ver'] = 0
+    doc['time'] = time.time()
+
+
+p = {
+    '_id': '5A236DNAC6NMS5XIBUMHTY2A',
+    'ver': 0,
+    'title': '2 Clip Demo',
+    'db_name': 'novacut-0-5a236dnac6nms5xibumhty2a',
+    'time': 1327022245.45872,
+    'atime': 1327022245.45872,
+    'type': 'novacut/project',
+}
+
+env = dmedia_env()
+db = Database('novacut-0', env)
+db.ensure()
+project = Database(p['db_name'], env)
+if project.ensure():
+    project.post(p)
+    project.post({'docs': docs}, '_bulk_docs')
+try:
+    db.save(p)
+except Conflict:
+    pass
+db.post({'docs': docs}, '_bulk_docs')
+
+root = schema.save_to_intrinsic('AUABDULVRZIBH727GQP2HXSA', project, db)
+print('root:', root)
+
+node = {
+    'muxer': {'name': 'oggmux'},
+    'video': {
+        'encoder': {
+            'name': 'theoraenc',
+            'props': {
+                'quality': 52,
+            },
+        },
+        'filter': {
+            'mime': 'video/x-raw-yuv',
+            'caps': {
+                'width': 960,
+                'height': 540,
+            },
+        },
+    },
+}
+doc = schema.create_settings(node)
+try:
+    db.save(doc)
+except Conflict:
+    pass
+print('settings:', doc['_id'])
+
+doc = schema.create_job(root, doc['_id'])
+try:
+    db.save(doc)
+except Conflict:
+    pass
+print('job:', doc['_id'])
+
+

=== modified file 'debian/control'
--- debian/control	2012-01-17 07:29:22 +0000
+++ debian/control	2012-01-20 15:32:24 +0000
@@ -18,6 +18,7 @@
     python-gst0.10,
     python-dbus,
     dmedia (>= 12.01),
+    dc3 (>= 12.01),
     python3-microfiber (>= 12.01),
     python3-userwebkit (>= 12.01),
     python3-gi | python3-gobject,

=== added file 'demo.json'
--- demo.json	1970-01-01 00:00:00 +0000
+++ demo.json	2012-01-20 15:32:24 +0000
@@ -0,0 +1,157 @@
+[ 
+    {
+        "_id": "AUABDULVRZIBH727GQP2HXSA", 
+        "node": {
+            "src": [
+                "XBIMKG7RJRSCNBWLI24BMIVS", 
+                "THYLBLNPTA2BBFSBGPUDSE3J", 
+                "TNSLSNXN7UCRC6XECSZ46LHC", 
+                "7FR4UH4JQPO4ISOPOWFDJ3FO", 
+                "SZ6A53C2YTYQMUMLY3SXWHKX", 
+                "5B6QDHAFTHJUU3TWX6JWE5TV", 
+                "QD3FLQVR5TQIQDQHXAZ5EPXM", 
+                "WXW4VPQJDG4K5XVIHX5ZTVBJ"
+            ], 
+            "type": "sequence"
+        }, 
+        "type": "novacut/node"
+    }, 
+    {
+        "_id": "WXW4VPQJDG4K5XVIHX5ZTVBJ", 
+        "node": {
+            "src": "VQIXPULW3G77W4XLGROMEDGFAH2XJBN4SAVFUGOZRFSIVU7N", 
+            "start": {
+                "frame": 421
+            }, 
+            "stop": {
+                "frame": 436
+            }, 
+            "stream": "video", 
+            "type": "slice"
+        }, 
+        "type": "novacut/node"
+    }, 
+    {
+        "_id": "QD3FLQVR5TQIQDQHXAZ5EPXM", 
+        "node": {
+            "src": "W62OZLFQUSKE4K6SLJWJ4EHFDUTRLD7JKQXUQMDJSSUG6TAQ", 
+            "start": {
+                "frame": 294
+            }, 
+            "stop": {
+                "frame": 309
+            }, 
+            "stream": "video", 
+            "type": "slice"
+        }, 
+        "type": "novacut/node"
+    }, 
+    {
+        "_id": "5B6QDHAFTHJUU3TWX6JWE5TV", 
+        "node": {
+            "src": "VQIXPULW3G77W4XLGROMEDGFAH2XJBN4SAVFUGOZRFSIVU7N", 
+            "start": {
+                "frame": 381
+            }, 
+            "stop": {
+                "frame": 406
+            }, 
+            "stream": "video", 
+            "type": "slice"
+        }, 
+        "type": "novacut/node"
+    }, 
+    {
+        "_id": "SZ6A53C2YTYQMUMLY3SXWHKX", 
+        "node": {
+            "src": "W62OZLFQUSKE4K6SLJWJ4EHFDUTRLD7JKQXUQMDJSSUG6TAQ", 
+            "start": {
+                "frame": 244
+            }, 
+            "stop": {
+                "frame": 269
+            }, 
+            "stream": "video", 
+            "type": "slice"
+        }, 
+        "type": "novacut/node"
+    }, 
+    {
+        "_id": "7FR4UH4JQPO4ISOPOWFDJ3FO", 
+        "node": {
+            "src": "VQIXPULW3G77W4XLGROMEDGFAH2XJBN4SAVFUGOZRFSIVU7N", 
+            "start": {
+                "frame": 318
+            }, 
+            "stop": {
+                "frame": 356
+            }, 
+            "stream": "video", 
+            "type": "slice"
+        }, 
+        "type": "novacut/node"
+    }, 
+    {
+        "_id": "TNSLSNXN7UCRC6XECSZ46LHC", 
+        "node": {
+            "src": "W62OZLFQUSKE4K6SLJWJ4EHFDUTRLD7JKQXUQMDJSSUG6TAQ", 
+            "start": {
+                "frame": 168
+            }, 
+            "stop": {
+                "frame": 206
+            }, 
+            "stream": "video", 
+            "type": "slice"
+        }, 
+        "type": "novacut/node"
+    }, 
+    {
+        "_id": "THYLBLNPTA2BBFSBGPUDSE3J", 
+        "node": {
+            "src": "VQIXPULW3G77W4XLGROMEDGFAH2XJBN4SAVFUGOZRFSIVU7N", 
+            "start": {
+                "frame": 230
+            }, 
+            "stop": {
+                "frame": 280
+            }, 
+            "stream": "video", 
+            "type": "slice"
+        }, 
+        "type": "novacut/node"
+    }, 
+    {
+        "_id": "XBIMKG7RJRSCNBWLI24BMIVS", 
+        "node": {
+            "src": "W62OZLFQUSKE4K6SLJWJ4EHFDUTRLD7JKQXUQMDJSSUG6TAQ", 
+            "start": {
+                "frame": 68
+            }, 
+            "stop": {
+                "frame": 118
+            }, 
+            "stream": "video", 
+            "type": "slice"
+        }, 
+        "type": "novacut/node"
+    }, 
+    {
+        "_id": "W62OZLFQUSKE4K6SLJWJ4EHFDUTRLD7JKQXUQMDJSSUG6TAQ", 
+        "framerate": {
+            "denom": 1, 
+            "num": 25
+        }, 
+        "samplerate": 48000, 
+        "type": "dmedia/file"
+    }, 
+    {
+        "_id": "VQIXPULW3G77W4XLGROMEDGFAH2XJBN4SAVFUGOZRFSIVU7N", 
+        "framerate": {
+            "denom": 1, 
+            "num": 25
+        }, 
+        "samplerate": 48000, 
+        "type": "dmedia/file"
+    }
+]

=== modified file 'novacut-cli'
--- novacut-cli	2012-01-17 08:37:54 +0000
+++ novacut-cli	2012-01-20 15:32:24 +0000
@@ -105,6 +105,12 @@
         return '{} was running for {}'.format(self.bus, minsec(seconds))
 
 
+class Render(_Method):
+    'Render an edit'
+
+    args = ['job_id']
+
+
 
 parser = optparse.OptionParser(
     usage='%prog METHOD [ARGS...]',

=== added file 'novacut-renderer'
--- novacut-renderer	1970-01-01 00:00:00 +0000
+++ novacut-renderer	2012-01-20 15:32:24 +0000
@@ -0,0 +1,50 @@
+#!/usr/bin/python
+
+# novacut: the collaborative video editor
+# Copyright (C) 2011 Novacut Inc
+#
+# This file is part of `novacut`.
+#
+# `novacut` is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# `novacut` 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 Affero General Public License for
+# more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with `novacut`.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors:
+#   Jason Gerard DeRose <[e-mail]>
+
+"""
+Script to fire-off a render.
+"""
+
+import optparse
+import novacut2
+
+import gobject
+import dbus
+from dbus.mainloop.glib import DBusGMainLoop
+
+
+gobject.threads_init()
+DBusGMainLoop(set_as_default=True)
+session = dbus.SessionBus()
+
+
+parser = optparse.OptionParser(
+	version=novacut2.__version__,
+)
+(options, args) = parser.parse_args()
+job_id = args[0]
+
+from novacut2.worker import Worker
+worker = Worker()
+_id = worker.run(job_id)
+print(_id)

=== modified file 'novacut-service'
--- novacut-service	2012-01-17 05:42:15 +0000
+++ novacut-service	2012-01-20 15:32:24 +0000
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 
 # novacut: the collaborative video editor
 # Copyright (C) 2011 Novacut Inc
@@ -31,31 +31,42 @@
 import optparse
 import json
 from os import path
+from threading import Thread
+import subprocess
 
 import dbus
 import dbus.service
 from dbus.mainloop.glib import DBusGMainLoop
-import gobject
+from gi.repository import GObject
 
-import novacut2
+import novacut
 
 
 BUS = 'com.novacut.Renderer'
 IFACE = BUS
 
-gobject.threads_init()
+GObject.threads_init()
 DBusGMainLoop(set_as_default=True)
 session = dbus.SessionBus()
 
 
-def dumps(obj):
-    return json.dumps(obj, sort_keys=True, separators=(',', ': '), indent=4)
+renderer = path.join(path.dirname(__file__), 'novacut-renderer')
+assert path.isfile(renderer)
+
+
+def _start_thread(target, *args):
+    thread = Thread(target=target, args=args)
+    thread.daemon = True
+    thread.start()
+    return thread
 
 
 class Service(dbus.service.Object):
+    workers = {}
+
     def __init__(self, bus):
         self.bus = bus
-        self.mainloop = gobject.MainLoop()
+        self.mainloop = GObject.MainLoop()
         super(Service, self).__init__(session, object_path='/')
         self.busname = dbus.service.BusName(bus, session)
 
@@ -65,12 +76,17 @@
     def kill(self):
         self.mainloop.quit()
 
+    def render(self, job_id):
+        cmd = [renderer, job_id]
+        file_id = subprocess.check_output(cmd).decode('utf-8')
+        self.RenderFinished(job_id, file_id)
+
     @dbus.service.method(IFACE, in_signature='', out_signature='s')
     def Version(self):
         """
         Return Novacut version.
         """
-        return novacut2.__version__
+        return novacut.__version__
 
     @dbus.service.method(IFACE, in_signature='', out_signature='i')
     def Kill(self):
@@ -80,9 +96,23 @@
         self.kill()
         return int(time.time() - start_time)
 
+    @dbus.service.method(IFACE, in_signature='s', out_signature='b')
+    def Render(self, job_id):
+        """
+        Render an edit.
+        """
+        if job_id in self.workers:
+            return False
+        self.workers[job_id] = _start_thread(self.render, job_id)
+        return True
+
+    @dbus.service.signal(IFACE, signature='ss')
+    def RenderFinished(self, job_id, file_id):
+        del self.workers[job_id]
+
 
 parser = optparse.OptionParser(
-	version=novacut2.__version__,
+	version=novacut.__version__,
 )
 parser.add_option('--bus',
     help='DBus bus name; default is {!r}'.format(BUS),

=== modified file 'novacut/schema.py'
--- novacut/schema.py	2012-01-17 12:15:44 +0000
+++ novacut/schema.py	2012-01-20 15:32:24 +0000
@@ -132,7 +132,7 @@
 from collections import namedtuple
 
 from skein import skein512
-from microfiber import random_id, RANDOM_B32LEN
+from microfiber import random_id, RANDOM_B32LEN, Conflict
 from dmedia.schema import (
     _label,
     _value,
@@ -267,6 +267,17 @@
     return inode.id
 
 
+def save_to_intrinsic(root, src, dst):
+    results = {}
+    iroot = intrinsic_graph(root, src.get, results)
+    for inode in results.values():
+        doc = create_inode(inode)
+        try:
+            dst.save(doc)
+        except Conflict:
+            pass
+    return iroot
+
 
 def check_novacut(doc):
     """
@@ -411,7 +422,46 @@
             }
         },
         'ver': VER,
-        'type': 'novacut/node',
+        'type': 'novacut/inode',
+        'time': time.time(),
+        'node': inode.node,
+        'renders': {},
+    }
+
+
+def create_settings(node):
+    inode = intrinsic_node(node)
+    return {
+        '_id': inode.id,
+        '_attachments': {
+            'node': {
+                'data': b64encode(inode.data).decode('utf-8'),
+                'content_type': 'application/json',
+            }
+        },
+        'ver': VER,
+        'type': 'novacut/settings',
+        'time': time.time(),
+        'node': inode.node,
+    }
+
+
+def create_job(root, settings):
+    node = {
+        'root': root,
+        'settings': settings,
+    }
+    inode = intrinsic_node(node)
+    return {
+        '_id': inode.id,
+        '_attachments': {
+            'node': {
+                'data': b64encode(inode.data).decode('utf-8'),
+                'content_type': 'application/json',
+            }
+        },
+        'ver': VER,
+        'type': 'novacut/job',
         'time': time.time(),
         'node': inode.node,
         'renders': {},

=== modified file 'novacut2/builder.py'
--- novacut2/builder.py	2012-01-18 01:02:46 +0000
+++ novacut2/builder.py	2012-01-20 15:32:24 +0000
@@ -61,11 +61,11 @@
 
 
 class LiveBuilder(Builder):
-    def __init__(self, project_id):
+    def __init__(self):
         self.Dmedia = session.get_object('org.freedesktop.Dmedia', '/')
         env = json.loads(self.Dmedia.GetEnv())
         env['url'] = env['url'].encode('utf-8')
-        self.db = Database(project_db_name(project_id), env)
+        self.db = Database('novacut-0', env)
         self._cache = {}
 
     def resolve_file(self, _id):

=== added file 'novacut2/extractor.py'
--- novacut2/extractor.py	1970-01-01 00:00:00 +0000
+++ novacut2/extractor.py	2012-01-20 15:32:24 +0000
@@ -0,0 +1,186 @@
+# novacut: the distributed video editor
+# Copyright (C) 2011 Novacut Inc
+#
+# This file is part of `novacut`.
+#
+# `novacut` is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# `novacut` 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 Affero General Public License for
+# more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with `novacut`.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors:
+#   Jason Gerard DeRose <[e-mail]>
+
+import sys
+import gst
+import gobject
+
+
+gobject.threads_init()
+
+
+class FakeBin(gst.Bin):
+    def __init__(self, doc, rate):
+        super(FakeBin, self).__init__()
+        self._doc = doc
+        self._q = gst.element_factory_make('queue')
+        self._rate = gst.element_factory_make(rate)
+        self._sink = gst.element_factory_make('fakesink')
+        self.add(self._q, self._rate, self._sink)
+        self._q.link(self._rate)
+        self._rate.link(self._sink)
+
+        # Ghost Pads
+        pad = self._q.get_pad('sink')
+        self.add_pad(
+            gst.GhostPad('sink', pad)
+        )
+        pad.connect('notify::caps', self._on_notify_caps)
+
+    def _get_doc(self):
+        self._finalize()
+        return self._doc
+        
+    def _query_duration(self, pad):
+        q = gst.query_new_duration(gst.FORMAT_TIME)
+        if pad.get_peer().query(q):
+            (format, duration) = q.parse_duration()
+            if format == gst.FORMAT_TIME:
+                return duration
+
+
+class VideoBin(FakeBin):
+    def __init__(self, doc):
+        super(VideoBin, self).__init__(doc, 'videorate')
+
+    def _on_notify_caps(self, pad, args):
+        caps = pad.get_negotiated_caps()
+        if not caps:
+            return
+        d = caps[0]
+        num = d['framerate'].num
+        denom = d['framerate'].denom
+        self._doc['framerate'] = {
+            'num': num,
+            'denom': denom,
+        }
+        self._doc['width'] = d['width']
+        self._doc['height'] = d['height']
+        ns = self._query_duration(pad)
+        if ns:
+            self._doc['video_ns'] = ns
+            self._doc['frames'] = ns * num / denom / gst.SECOND
+
+    def _finalize(self):
+        self._doc['frames2'] = self._rate.get_property('in')
+
+
+class AudioBin(FakeBin):
+    def __init__(self, doc):
+        super(AudioBin, self).__init__(doc, 'audiorate')
+
+    def _on_notify_caps(self, pad, args):
+        caps = pad.get_negotiated_caps()
+        if not caps:
+            return
+        d = caps[0]
+        self._doc['samplerate'] = d['rate']
+        self._doc['channels'] = d['channels']
+        ns = self._query_duration(pad)
+        if ns:
+            self._doc['audio_ns'] = ns
+            self._doc['samples'] = d['rate'] * ns / gst.SECOND
+
+    def _finalize(self):
+        # FIXME: why is this so worthless?
+        if 'samples' not in self._doc:
+            self._doc['samples'] = self._rate.get_property('in')
+
+
+class Extractor(object):
+    def __init__(self, filename):
+        self.doc = {'video_ns': 0, 'audio_ns': 0}
+        self.mainloop = gobject.MainLoop()
+        self.pipeline = gst.Pipeline()
+
+        # Create bus and connect several handlers
+        self.bus = self.pipeline.get_bus()
+        self.bus.add_signal_watch()
+        self.bus.connect('message::eos', self.on_eos)
+        self.bus.connect('message::error', self.on_error)
+
+        # Create elements
+        self.src = gst.element_factory_make('filesrc')
+        self.dec = gst.element_factory_make('decodebin2')
+
+        # Set properties
+        self.src.set_property('location', filename)
+
+        # Connect handler for 'new-decoded-pad' signal
+        self.dec.connect('pad-added', self.on_pad_added)
+        self.dec.connect('no-more-pads', self.on_no_more_pads)
+        self.typefind = self.dec.get_by_name('typefind')
+        self.typefind.connect('have-type', self.on_have_type)
+
+        # Add elements to pipeline
+        self.pipeline.add(self.src, self.dec)
+
+        # Link elements
+        self.src.link(self.dec)
+
+        self.audio = None
+        self.video = None
+
+    def run(self):
+        self.pipeline.set_state(gst.STATE_PLAYING)
+        self.mainloop.run()
+
+    def kill(self):
+        ns = max(self.doc['video_ns'], self.doc['audio_ns'])
+        self.doc['seconds'] = float(ns) / gst.SECOND
+        self.pipeline.set_state(gst.STATE_NULL)
+        self.pipeline.get_state()
+        self.mainloop.quit()
+
+    def link_pad(self, pad, name):
+        cls = {'audio': AudioBin, 'video': VideoBin}[name]
+        fakebin = cls(self.doc)
+        self.pipeline.add(fakebin)
+        pad.link(fakebin.get_pad('sink'))
+        fakebin.set_state(gst.STATE_PLAYING)
+        return fakebin
+
+    def on_pad_added(self, element, pad):
+        name = pad.get_caps()[0].get_name()
+        if name.startswith('audio/'):
+            assert self.audio is None
+            self.audio = self.link_pad(pad, 'audio')
+        elif name.startswith('video/'):
+            assert self.video is None
+            self.video = self.link_pad(pad, 'video')
+
+    def on_no_more_pads(self, element):
+        print('no more decoded pads')
+
+    def on_have_type(self, element, prop, caps):
+        self.doc['content_type'] = caps.to_string()
+
+    def on_eos(self, bus, msg):
+        if self.video:
+            self.video._finalize()
+        self.kill()
+
+    def on_error(self, bus, msg):
+        error = msg.parse_error()[1]
+        self.kill()
+        print(error)
+        sys.exit(2)
+

=== modified file 'novacut2/renderer.py'
--- novacut2/renderer.py	2012-01-17 05:15:04 +0000
+++ novacut2/renderer.py	2012-01-20 15:32:24 +0000
@@ -251,14 +251,15 @@
 
 
 class Renderer(object):
-    def __init__(self, job, builder, dst):
+    def __init__(self, root, settings, builder, dst):
         """
         Initialize.
 
         :param job: a ``dict`` describing the transcode to perform.
         :param fs: a `FileStore` instance in which to store transcoded file
         """
-        self.job = job
+        self.root = root
+        self.settings = settings
         self.builder = builder
         self.mainloop = gobject.MainLoop()
         self.pipeline = gst.Pipeline()
@@ -270,8 +271,8 @@
         self.bus.connect('message::error', self.on_error)
 
         # Create elements
-        self.src = builder.build(job['src'])
-        self.mux = make_element(job['muxer'])
+        self.src = builder.build(root)
+        self.mux = make_element(settings['muxer'])
         self.sink = gst.element_factory_make('filesink')
 
         # Add elements to pipeline
@@ -301,15 +302,15 @@
 
     def link_pad(self, pad, name, key):
         log.info('link_pad: %r, %r, %r', pad, name, key)
-        if key in self.job:
+        if key in self.settings:
             klass = {'audio': AudioEncoder, 'video': VideoEncoder}[key]
-            el = klass(self.job[key])
+            el = klass(self.settings[key])
         else:
             el = gst.element_factory_make('fakesink')
         self.pipeline.add(el)
         log.info('Linking pad %r with %r', name, el)
         pad.link(el.get_compatible_pad(pad, pad.get_caps()))
-        if key in self.job:
+        if key in self.settings:
             el.link(self.mux)
         el.set_state(gst.STATE_PLAYING)
         return el

=== modified file 'novacut2/tests/test_renderer.py'
--- novacut2/tests/test_renderer.py	2012-01-17 05:15:04 +0000
+++ novacut2/tests/test_renderer.py	2012-01-20 15:32:24 +0000
@@ -535,26 +535,27 @@
         tmp = TempDir()
         builder = DummyBuilder(docs)
 
-        job = {
-            'src': sequence1,
+        root = sequence1
+        settings = {
             'muxer': {'name': 'oggmux'},
         }
         dst = tmp.join('out1.ogv')
-        inst = renderer.Renderer(job, builder, dst)
+        inst = renderer.Renderer(root, settings, builder, dst)
 
-        self.assertTrue(inst.job is job)
-        self.assertTrue(inst.builder is builder)
+        self.assertIs(inst.root, root)
+        self.assertIs(inst.settings, settings)
+        self.assertIs(inst.builder, builder)
 
         self.assertIsInstance(inst.src, gst.Element)
-        self.assertTrue(inst.src.get_parent() is inst.pipeline)
+        self.assertIs(inst.src.get_parent(), inst.pipeline)
         self.assertEqual(inst.src.get_factory().get_name(), 'gnlcomposition')
 
         self.assertIsInstance(inst.mux, gst.Element)
-        self.assertTrue(inst.mux.get_parent() is inst.pipeline)
+        self.assertIs(inst.mux.get_parent(), inst.pipeline)
         self.assertEqual(inst.mux.get_factory().get_name(), 'oggmux')
 
         self.assertIsInstance(inst.sink, gst.Element)
-        self.assertTrue(inst.sink.get_parent() is inst.pipeline)
+        self.assertIs(inst.sink.get_parent(), inst.pipeline)
         self.assertEqual(inst.sink.get_factory().get_name(), 'filesink')
         self.assertEqual(inst.sink.get_property('location'), dst)
 

=== added file 'novacut2/worker.py'
--- novacut2/worker.py	1970-01-01 00:00:00 +0000
+++ novacut2/worker.py	2012-01-20 15:32:24 +0000
@@ -0,0 +1,82 @@
+# novacut: the distributed video editor
+# Copyright (C) 2011 Novacut Inc
+#
+# This file is part of `novacut`.
+#
+# `novacut` is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# `novacut` 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 Affero General Public License for
+# more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with `novacut`.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors:
+#   Jason Gerard DeRose <[e-mail]>
+
+import json
+
+import dbus
+from dbus.mainloop.glib import DBusGMainLoop
+import gobject
+from dc3lib.microfiber import Database
+
+from renderer import Builder, Renderer
+
+
+gobject.threads_init()
+DBusGMainLoop(set_as_default=True)
+session = dbus.SessionBus()
+
+
+class LiveBuilder(Builder):
+    def __init__(self, Dmedia, db):
+        self.Dmedia = Dmedia
+        self.db = db
+        self._cache = {}
+
+    def resolve_file(self, _id):
+        return self.Dmedia.Resolve(_id)
+
+    def get_doc(self, _id):
+        try:
+            return self._cache[_id]
+        except KeyError:
+            doc = self.db.get(_id)
+            self._cache[_id] = doc
+            return doc
+
+
+class Worker(object):
+    def __init__(self):
+        self.Dmedia = session.get_object('org.freedesktop.Dmedia', '/')
+        env = json.loads(self.Dmedia.GetEnv())
+        env['url'] = env['url'].encode('utf-8')
+        self.novacut = Database('novacut-0', env)
+        self.dmedia = Database('dmedia-0', env)
+
+    def run(self, job_id):
+        job = self.novacut.get(job_id)
+        root = job['node']['root']
+        settings = self.novacut.get(job['node']['settings'])
+        builder = LiveBuilder(self.Dmedia, self.novacut)
+        dst = self.Dmedia.AllocateTmp()
+        renderer = Renderer(root, settings['node'], builder, dst)
+        renderer.run()
+        _id = self.Dmedia.HashAndMove(dst, 'render')
+        doc = self.dmedia.get(_id)
+        doc['render_of'] = job_id
+        self.dmedia.save(doc)
+        job['renders'][_id] = {
+            'bytes': doc['bytes'],
+            'time': doc['time'],
+        }
+        self.novacut.save(job)
+        return _id
+        
+        

=== modified file 'setup.py'
--- setup.py	2012-01-17 08:37:54 +0000
+++ setup.py	2012-01-20 15:32:24 +0000
@@ -147,6 +147,12 @@
         ('share/icons/hicolor/48x48/apps',
             ['data/novacut.svg']
         ),
+        ('lib/novacut',
+            ['novacut-service'],
+        ),
+        ('share/dbus-1/services/',
+            ['data/com.novacut.Renderer.service']
+        ),
     ],
     cmdclass={'test': Test},
 )

=== modified file 'setup2.py'
--- setup2.py	2012-01-17 08:26:59 +0000
+++ setup2.py	2012-01-20 15:32:24 +0000
@@ -134,10 +134,7 @@
     packages=['novacut2'],
     data_files=[
         ('lib/novacut',
-            ['novacut-service'],
-        ),
-        ('share/dbus-1/services/',
-            ['data/com.novacut.Renderer.service']
+            ['novacut-renderer'],
         ),
     ],
 )