pitivi r1169 - in branches/SOC_2008_BLEWIS: . pitivi/timeline

[edwardrv svn gnome org]

Author: edwardrv
Date: Tue Jul 15 07:53:25 2008
New Revision: 1169
URL: http://svn.gnome.org/viewvc/pitivi?rev=1169&view=rev

Log:
* pitivi/timeline/objects.py:
* pitivi/timeline/source.py:
Refactor TimelineSource to be more generic.
Don't use -1 for invalid (media_)start/duration but gst.CLOCK_TIME_NONE
for invalid start and 0 for invalid durations.


Modified:
   branches/SOC_2008_BLEWIS/ChangeLog
   branches/SOC_2008_BLEWIS/pitivi/timeline/objects.py
   branches/SOC_2008_BLEWIS/pitivi/timeline/source.py

Modified: branches/SOC_2008_BLEWIS/pitivi/timeline/objects.py
==============================================================================
--- branches/SOC_2008_BLEWIS/pitivi/timeline/objects.py	(original)
+++ branches/SOC_2008_BLEWIS/pitivi/timeline/objects.py	Tue Jul 15 07:53:25 2008
@@ -313,8 +313,8 @@
                                  (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, ))
         }
 
-    def __init__(self, factory=None, start=-1, duration=-1,
-                 media_type=MEDIA_TYPE_NONE, name="", **kwargs):
+    def __init__(self, factory=None, start=gst.CLOCK_TIME_NONE,
+                 duration=0, media_type=MEDIA_TYPE_NONE, name="", **kwargs):
         BrotherObjects.__init__(self, **kwargs)
         self.name = name
         gst.log("new TimelineObject :%s %r" % (name, self))
@@ -349,18 +349,18 @@
             self.gnlobject.connect("notify::duration", self._startDurationChangedCb)
             self._setStartDurationTime(self.start, self.duration, True)
 
-    def _setStartDurationTime(self, start=-1, duration=-1, force=False):
+    def _setStartDurationTime(self, start=gst.CLOCK_TIME_NONE, duration=0, force=False):
         # really modify the start/duration time
         self.gnlobject.info("start:%s , duration:%s" %( gst.TIME_ARGS(start),
                                                         gst.TIME_ARGS(duration)))
-        if not duration == -1 and (not self.duration == duration or force):
+        if duration and (not self.duration == duration or force):
             self.duration = duration
             self.gnlobject.set_property("duration", long(duration))
-        if not start == -1 and (not self.start == start or force):
+        if not start == gst.CLOCK_TIME_NONE and (not self.start == start or force):
             self.start = start
             self.gnlobject.set_property("start", long(start))
 
-    def setStartDurationTime(self, start=-1, duration=-1):
+    def setStartDurationTime(self, start=gst.CLOCK_TIME_NONE, duration=0):
         """ sets the start and/or duration time """
         self._setStartDurationTime(start, duration)
         if self.linked:
@@ -372,22 +372,21 @@
         if not gnlobject == self.gnlobject:
             gst.warning("We're receiving signals from an object we dont' control (self.gnlobject:%r, gnlobject:%r)" % (self.gnlobject, gnlobject))
         self.gnlobject.debug("property:%s" % property.name)
-        start = -1
-        duration = -1
+        start = gst.CLOCK_TIME_NONE
+        duration = 0
         if property.name == "start":
             start = gnlobject.get_property("start")
             if start == self.start:
-                start = -1
+                start = gst.CLOCK_TIME_NONE
             else:
                 self.start = long(start)
         elif property.name == "duration":
             duration = gnlobject.get_property("duration")
             if duration == self.duration:
-                duration = -1
+                duration = 0
             else:
                 self.gnlobject.debug("duration changed:%s" % gst.TIME_ARGS(duration))
                 self.duration = long(duration)
-        #if not start == -1 or not duration == -1:
         self.emit("start-duration-changed", self.start, self.duration)
 
 

Modified: branches/SOC_2008_BLEWIS/pitivi/timeline/source.py
==============================================================================
--- branches/SOC_2008_BLEWIS/pitivi/timeline/source.py	(original)
+++ branches/SOC_2008_BLEWIS/pitivi/timeline/source.py	Tue Jul 15 07:53:25 2008
@@ -32,14 +32,120 @@
     """
     Base class for all sources (O input)
     """
+    __gsignals__ = {
+        "media-start-duration-changed" : ( gobject.SIGNAL_RUN_LAST,
+                                       gobject.TYPE_NONE,
+                                       (gobject.TYPE_UINT64, gobject.TYPE_UINT64))
+        }
+
 
     __data_type__ = "timeline-source"
 
-    # FIXME : media_start and media_duration should be in this class
 
-    def __init__(self, **kw):
+    def __init__(self, media_start=gst.CLOCK_TIME_NONE,
+                 media_duration=0, **kw):
+        self.media_start = media_start
+        self.media_duration = media_duration
         TimelineObject.__init__(self, **kw)
 
+    def _makeGnlObject(self):
+        gst.debug("Making a source for %r" % self)
+        if self.isAudio():
+            caps = gst.caps_from_string("audio/x-raw-int;audio/x-raw-float")
+            postfix = "audio"
+        elif self.isVideo():
+            caps = gst.caps_from_string("video/x-raw-yuv;video/x-raw-rgb")
+            postfix = "video"
+        else:
+            raise NameError, "media type is NONE !"
+
+        if self.factory:
+            self.factory.lastbinid = self.factory.lastbinid + 1
+            sourcename =  "source-" + self.name + "-" + postfix + str(self.factory.lastbinid)
+        else:
+            sourcename = "source-" + self.name + "-" + postfix
+        gnl = gst.element_factory_make("gnlsource", sourcename)
+
+        try:
+            gst.debug("calling makeGnlSourceContents()")
+            obj = self.makeGnlSourceContents()
+        except:
+            gst.debug("Failure in calling self.makeGnlSourceContents()")
+            return None
+        gnl.add(obj)
+
+        # set properties
+        gnl.set_property("media-duration", long(self.media_duration))
+        gnl.set_property("media-start", long(self.media_start))
+        gnl.set_property("caps", caps)
+        gnl.connect("notify::media-start", self._mediaStartDurationChangedCb)
+        gnl.connect("notify::media-duration", self._mediaStartDurationChangedCb)
+        return gnl
+
+    def makeGnlSourceContents(self):
+        """
+        Return the contents of the gnlsource.
+        Should be a single element (or bin).
+
+        Sub-classes not implementing this method will need to override
+        the _makeGnlObject() method.
+        """
+        raise NotImplementedError
+
+    def _setMediaStartDurationTime(self, start=gst.CLOCK_TIME_NONE,
+                                   duration=0):
+        gst.info("TimelineFileSource %s start:%s , duration:%s" % (
+            self,
+            gst.TIME_ARGS(start),
+            gst.TIME_ARGS(duration)))
+        gst.info("TimelineFileSource %s EXISTING start:%s , duration:%s" % (
+            self,
+            gst.TIME_ARGS(self.media_start),
+            gst.TIME_ARGS(self.media_duration)))
+        if duration > 0 and not self.media_duration == duration:
+            self.gnlobject.set_property("media-duration", long(duration))
+        if not start == gst.CLOCK_TIME_NONE and not self.media_start == start:
+            self.gnlobject.set_property("media-start", long(start))
+
+    def setMediaStartDurationTime(self, start=gst.CLOCK_TIME_NONE,
+                                  duration=0):
+        """ sets the media start/duration time """
+        if not start == gst.CLOCK_TIME_NONE and start < 0:
+            gst.warning("Can't set start values < 0 !")
+            return
+        if duration < 0:
+            gst.warning("Can't set durations < 0 !")
+            return
+        self._setMediaStartDurationTime(start, duration)
+        if self.linked and isinstance(self.linked, TimelineFileSource):
+            self.linked._setMediaStartDurationTime(start, duration)
+
+    def _mediaStartDurationChangedCb(self, gnlobject, property):
+        gst.log("%r %s %s" % (gnlobject, property, property.name))
+        mstart = None
+        mduration = None
+        if property.name == "media-start":
+            mstart = gnlobject.get_property("media-start")
+            gst.log("%s %s" % (gst.TIME_ARGS(mstart),
+                               gst.TIME_ARGS(self.media_start)))
+            if self.media_start == gst.CLOCK_TIME_NONE:
+                self.media_start = mstart
+            elif mstart == self.media_start:
+                mstart = None
+            else:
+                self.media_start = mstart
+        elif property.name == "media-duration":
+            mduration = gnlobject.get_property("media-duration")
+            gst.log("%s %s" % (gst.TIME_ARGS(mduration),
+                               gst.TIME_ARGS(self.media_duration)))
+            if mduration == self.media_duration:
+                mduration = None
+            else:
+                self.media_duration = mduration
+        if not mstart == None or not mduration == None:
+            self.emit("media-start-duration-changed",
+                      self.media_start, self.media_duration)
+
 class TimelineBlankSource(TimelineSource):
     """
     Blank source for testing purposes.
@@ -49,9 +155,9 @@
     __requires_factory__ = False
 
     def __init__(self, **kw):
-        TimelineObject.__init__(self, **kw)
+        TimelineSource.__init__(self, **kw)
 
-    def _makeGnlObject(self):
+    def makeGnlSourceContents(self):
         if self.isAudio():
             # silent audiotestsrc
             src = gst.element_factory_make("audiotestsrc")
@@ -62,10 +168,8 @@
             src.props.pattern = 2
         else:
             gst.error("Can only handle Audio OR Video sources")
-            return
-        gnl = gst.element_factory_make("gnlsource")
-        gnl.add(src)
-        return gnl
+            return None
+        return src
 
     def getExportSettings(self):
         return self.factory.getExportSettings()
@@ -79,58 +183,49 @@
     * 'media-duration' (int) : duration of the media
     * (optional) 'volume' (int) : volume of the audio
     """
-    __gsignals__ = {
-        "media-start-duration-changed" : ( gobject.SIGNAL_RUN_LAST,
-                                       gobject.TYPE_NONE,
-                                       (gobject.TYPE_UINT64, gobject.TYPE_UINT64))
-        }
-
     __data_type__ = "timeline-file-source"
 
-    def __init__(self, media_start=-1, media_duration=-1, **kw):
-        self.media_start = media_start
-        self.media_duration = media_duration
+    def __init__(self, **kw):
         TimelineSource.__init__(self, **kw)
 
     def _makeGnlObject(self):
-        gst.log("creating object")
+        gnlobject = TimelineSource._makeGnlObject(self)
+        if gnlobject == None:
+            return None
+
+        # we override start/duration
+        gnlobject.set_property("duration", long(1))
+        gnlobject.set_property("duration", long(self.factory.length))
+        gnlobject.set_property("start", long(0))
+
+        if self.media_start == gst.CLOCK_TIME_NONE:
+            self.media_start = 0
+        if self.media_duration == 0:
+            self.media_duration = self.factory.length
+
+        return gnlobject
+
+    def makeGnlSourceContents(self):
         if self.isAudio():
             caps = gst.caps_from_string("audio/x-raw-int;audio/x-raw-float")
-            postfix = "audio"
         elif self.isVideo():
             caps = gst.caps_from_string("video/x-raw-yuv;video/x-raw-rgb")
-            postfix = "video"
         else:
             raise NameError, "media type is NONE !"
-        self.factory.lastbinid = self.factory.lastbinid + 1
-
-        gnlobject = gst.element_factory_make("gnlsource", "source-" + self.name + "-" + postfix + str(self.factory.lastbinid))
         self.decodebin = SingleDecodeBin(caps=caps, uri=self.factory.name)
         if self.isAudio():
             self.volumeElement = gst.element_factory_make("volume", "internal-volume")
-            self.audioconv = gst.element_factory_make("audioconvert", "fdsjkljf")
+            self.audioconv = gst.element_factory_make("audioconvert", "audioconv")
             self.volumeBin = gst.Bin("volumebin")
             self.volumeBin.add(self.decodebin, self.audioconv, self.volumeElement)
             self.audioconv.link(self.volumeElement)
             self.decodebin.connect('pad-added', self._decodebinPadAddedCb)
             self.decodebin.connect('pad-removed', self._decodebinPadRemovedCb)
-            gnlobject.add(self.volumeBin)
+            bin = self.volumeBin
         else:
-            gnlobject.add(self.decodebin)
-        gnlobject.set_property("caps", caps)
-        gnlobject.set_property("start", long(0))
-        gnlobject.set_property("duration", long(self.factory.length))
-
-        if self.media_start == -1:
-            self.media_start = 0
-        if self.media_duration == -1:
-            self.media_duration = self.factory.length
-        gnlobject.set_property("media-duration", long(self.media_duration))
-        gnlobject.set_property("media-start", long(self.media_start))
-        gnlobject.connect("notify::media-start", self._mediaStartDurationChangedCb)
-        gnlobject.connect("notify::media-duration", self._mediaStartDurationChangedCb)
+            bin = self.decodebin
 
-        return gnlobject
+        return bin
 
     def _decodebinPadAddedCb(self, unused_dbin, pad):
         pad.link(self.audioconv.get_pad("sink"))
@@ -156,7 +251,7 @@
     def setVolume(self, level):
         if self.isAudio():
             self._setVolume(level)
-        else:
+        elif self.linked:
             self.linked._setVolume(level)
 
     def _makeBrother(self):
@@ -168,72 +263,25 @@
         if self.isVideo():
             if not self.factory.is_audio:
                 return None
-            brother = TimelineFileSource(media_start=self.media_start, media_duration=self.media_duration,
-                                         factory=self.factory, start=self.start, duration=self.duration,
+            brother = TimelineFileSource(media_start=self.media_start,
+                                         media_duration=self.media_duration,
+                                         factory=self.factory, start=self.start,
+                                         duration=self.duration,
                                          media_type=MEDIA_TYPE_AUDIO,
                                          name=self.name + "-brother")
         elif self.isAudio():
             if not self.factory.is_video:
                 return None
-            brother = TimelineFileSource(media_start=self.media_start, media_duration=self.media_duration,
-                                         factory=self.factory, start=self.start, duration=self.duration,
+            brother = TimelineFileSource(media_start=self.media_start,
+                                         media_duration=self.media_duration,
+                                         factory=self.factory, start=self.start,
+                                         duration=self.duration,
                                          media_type=MEDIA_TYPE_VIDEO,
                                          name=self.name + "-brother")
         else:
             brother = None
         return brother
 
-    def _setMediaStartDurationTime(self, start=-1, duration=-1):
-        gst.info("TimelineFileSource %s start:%s , duration:%s" % (
-            self,
-            gst.TIME_ARGS(start),
-            gst.TIME_ARGS(duration)))
-        gst.info("TimelineFileSource %s EXISTING start:%s , duration:%s" % (
-            self,
-            gst.TIME_ARGS(self.media_start),
-            gst.TIME_ARGS(self.media_duration)))
-        if not duration == -1 and not self.media_duration == duration:
-            self.gnlobject.set_property("media-duration", long(duration))
-        if not start == -1 and not self.media_start == start:
-            self.gnlobject.set_property("media-start", long(start))
-
-    def setMediaStartDurationTime(self, start=-1, duration=-1):
-        """ sets the media start/duration time """
-        if not start == -1 and start < 0:
-            gst.warning("Can't set start values < 0 !")
-            return
-        if not duration == -1 and duration <= 0:
-            gst.warning("Can't set durations <= 0 !")
-            return
-        self._setMediaStartDurationTime(start, duration)
-        if self.linked and isinstance(self.linked, TimelineFileSource):
-            self.linked._setMediaStartDurationTime(start, duration)
-
-    def _mediaStartDurationChangedCb(self, gnlobject, property):
-        gst.log("%r %s %s" % (gnlobject, property, property.name))
-        mstart = None
-        mduration = None
-        if property.name == "media-start":
-            mstart = gnlobject.get_property("media-start")
-            gst.log("%s %s" % (gst.TIME_ARGS(mstart),
-                               gst.TIME_ARGS(self.media_start)))
-            if self.media_start == -1:
-                self.media_start = mstart
-            elif mstart == self.media_start:
-                mstart = None
-            else:
-                self.media_start = mstart
-        elif property.name == "media-duration":
-            mduration = gnlobject.get_property("media-duration")
-            gst.log("%s %s" % (gst.TIME_ARGS(mduration),
-                               gst.TIME_ARGS(self.media_duration)))
-            if mduration == self.media_duration:
-                mduration = None
-            else:
-                self.media_duration = mduration
-        if not mstart == None or not mduration == None:
-            self.emit("media-start-duration-changed",
-                      self.media_start, self.media_duration)
 
     def getExportSettings(self):
         return self.factory.getExportSettings()