sensible-cinema 0.27.0 → 0.28.0

data/vendor/movie-content-editor-read-only/VLCMacVideo.py

@@ -0,0 +1,257 @@
+#! /usr/bin/python
+
+#import vlc
+import sys
+from PyQt4 import QtGui, QtCore, uic
+from Foundation import *
+from AppKit import NSView
+from Quartz import *
+from CoreFoundation import *
+import objc
+from objc import YES, NO, NULL
+import sip
+
+#objc.loadBundle("VLCKit",globals(),bundle_path=objc.pathForFramework("/Users/slloyd/Downloads/vlc/projects/macosx/framework/build/Debug/VLCKit.framework"))
+d='/Users/slloyd/Downloads/vlc/projects/macosx/framework/build/vlc_build_dir'
+d='/Applications/VLC.app/Contents/MacOS'
+TIME_RES = 10000
+
+"""The ideal way to do this would be to use the objc.loadBundle method to import the VLCKit framework already built for VLC.
+This would ideally build Python wrappers around all of the custom VLC objects we need and allow us to create them in Python
+directly without having to define the classes ourselves. I wasn't able to get this to work, so for now, I've defined just one
+of these classes myself (the VLCVideoView class) to allow us to have something that works"""
+
+
+
+"""Objective C class defined in Python. Lots of signatures to tell objc which methods to call. Some of them are apparently 
+unnecessary, but it wasn't clear to me which were needed and which weren't, so I left them all in. I suspect that they are
+unnecessary when overriding methods of a parent class, but I haven't confirmed that."""
+class VLCVideoView(NSView):
+
+    objc.synthesize('delegate', copy=True)
+    objc.synthesize('backColor',copy=True)
+    objc.synthesize('hasVideo', copy=True)
+    
+    #Initialize the VLCVideoView object. If running in 64-bit on SnowLeopard, it expects a CGRect rather than an NSRect
+    @objc.signature("@@:{_NSRect={_NSPoint=ff}{_NSSize=ff}}")
+#    @objc.signature("@@:{CGRect={CGPoint=dd}{CGSize=dd}}")
+    def initWithFrame_(self,rect):
+        self = super(VLCVideoView, self).initWithFrame_(rect)
+        if self is None: return None
+        self._delegate = None
+        self._backColor = NSColor.blackColor()
+        self._fillScreen = NO
+        self._hasVideo = NO
+        self.setStretchesVideo_(NO)
+        self.setAutoresizesSubviews_(YES)
+        
+        #probably need to figure out how to assign an appropriate layoutManager, but for now it's None
+        self.layoutManager =  None
+        return self
+    
+    @objc.signature("@@:")
+    def backColor(self):
+        return self._backColor
+    
+    @objc.signature("c@:")        
+    def hasVideo(self):
+        return self._hasVideo
+    
+    @objc.signature("@@:")
+    def delegate(self):
+        return self._delegate
+    
+    @objc.signature("v@:")    
+    def dealloc(self):
+        self._delegate = None
+        self._backColor = None
+        if self.layoutManager:
+            self.layoutManager.release()
+        super(VLCVideoView,self).dealloc()
+        
+    @objc.signature("v@:{_NSRect={_NSPoint=ff}{_NSSize=ff}}")    
+    def drawRect_(self,aRect):
+        self.lockFocus()
+        self.backColor().set()
+        NSRectFill(aRect)
+        self.unlockFocus()
+    
+    @objc.signature("c@:")        
+    def isOpaque(self):
+        return YES
+        
+        
+    @objc.signature("c@:")
+    def fillScreen(self):
+        if self.layoutManager:
+            return self.layoutManager.fillScreenEntirely()
+        return NO
+        
+    @objc.signature("v@:c")
+    def setFillScreen_(self,fillScreen):
+        #need to implement
+        return NO
+
+
+    @objc.signature("v@:{CALayer=#{_CALayerIvars=iII^{__CFArray}@^{_CALayerState}^{_CALayerState}^{_CALayerAnimation}[3^{_CALayerTransaction}]}}")
+    def addVoutLayer_(self, aLayer):
+        CATransaction.begin()
+        self.setWantsLayer_(YES)
+        rootLayer = self.layer()
+        aLayer.name = u"vlcopengllayer"
+        if self.layoutManager:
+            self.layoutManager.setOriginalVideoSize_(aLayer.bounds().size())
+        
+        rootLayer.setLayoutManager_(layoutManager)
+        rootLayer.insertSublayer_atIndex_(aLayer, 0)
+        aLayer.setNeedsDisplayOnBoundsChange_(True)
+        
+        CATransaction.commit()
+        self._hasVideo = YES
+        
+    @objc.signature("v@:@")    
+    def removeVoutLayer_(self, voutLayer):
+        CATransaction.begin()
+        voutLayer.removeFromSuperlayer()
+        CATransaction.commit()
+        self._hasVideo = NO
+        
+    @objc.signature("v@:c")
+    def setStretchesVideo_(self,value):
+        self._stretchesVideo = value;
+        
+           
+    @objc.signature("v@:@")    
+    def addVoutSubview_(self, aView):
+        aView.setFrame_(self.bounds())
+        self.addSubview_(aView)
+        aView.setAutoresizingMask_((NSViewHeightSizable|NSViewWidthSizable))
+
+    @objc.signature("v@:@")
+    def removeVoutSubview_(self, view):
+        #not doing anything right now
+        pass
+        
+    @objc.signature("c@:")    
+    def stretchesVideo(self):
+        return self._stretchesVideo
+        
+    @objc.signature("v@:@")    
+    def didAddSubview_(self, subview):
+        pass
+#        NSLog(u'A subview was added')
+        
+#    def __del__(self):
+#        self._delegate = None
+#        self._backColor = None
+#        self.layoutManager = None
+
+#app = QtGui.QApplication(sys.argv)
+
+
+"""This is the QtGui widget that will actually hold our video NSView video object defined above"""
+class MacVideo(QtGui.QWidget):
+    
+    def __init__(self, parent=None):
+        super(MacVideo,self).__init__(parent)    
+        self.videoLayout = QtGui.QVBoxLayout()
+        self.videoLayout.setContentsMargins(0,0,0,0)
+        self.setLayout(self.videoLayout)
+        
+        
+    def createVideoWindow(self,media_player):    
+        videoWidget = QtGui.QMacCocoaViewContainer(None)
+        self.videoLayout.addWidget(videoWidget)
+        videoView = VLCVideoView.alloc().init()
+        videoWidget.setCocoaView(sip.voidptr(objc.pyobjc_id(videoView)))
+        media_player.set_nsobject(objc.pyobjc_id(videoView))
+        videoView.release()
+        
+        
+    
+
+class MacPlayer(QtGui.QWidget):
+
+    
+    def __init__(self, player, parent=None):
+        super(MacPlayer,self).__init__(parent)
+        self.media_player = player
+        self.instance = self.media_player.get_instance()
+        self.videoWidget = None
+        
+        #import the Qt interface defined in VideoMac.ui
+        self.win = uic.loadUi("VideoMac.ui")
+        
+        """the poller is just a simple way to create an event to update the 
+        position slider and do any other interface updates we need"""
+        self.poller = QtCore.QTimer(self)
+        
+        #connect all of the buttons and sliders defined in the imported interface
+        self.poller.timeout.connect(self.updateInterface)
+        self.positionSlider = self.win.positionSlider
+        self.positionSlider.setMaximum(TIME_RES)
+        self.positionSlider.sliderPressed.connect(self.positionChanging)
+        self.positionSlider.sliderReleased.connect(self.positionChanged)
+        self.win.pauseButton.clicked.connect(self.play_pause)
+        self.win.stopButton.clicked.connect(self.stop)
+        
+        #start the poller and tell it to timeout every .1 s
+        self.poller.start(100)
+
+        #create the actual widget that will hold the vlc video
+        videoWidget = MacVideo()
+        videoWidget.createVideoWindow(self.media_player)
+        self.win.videoLayout.setContentsMargins(0,0,0,0)
+        self.win.videoLayout.addWidget(videoWidget)
+        self.win.show()        
+        
+        
+    def play(self):
+        self.media_player.play()
+        self.show()
+
+
+# right now if you try to stop the player on a mac, it crashes the program
+    def stop(self, checked):
+#        if self.videoWidget:
+#            self.videoWidget= None
+#        if self.media_player.get_media() is not None and self.media_descr is not None:
+#            self.media_player.stop()
+#        self.isPlaying = False
+#        self.media_player.stop()
+        return
+            
+    def changeVolume(self, newVolume):
+        self.instance.audio_set_volume(newVolume)
+        
+    def positionChanging(self):
+        self.poller.stop()
+    
+    def positionChanged(self):
+        self.changePosition()
+        self.poller.start(100)
+        
+    def play_pause(self,checked):
+        if checked or self.media_player.is_playing(): 
+            self.media_player.pause()
+        else:
+            self.media_player.play()
+    
+    def changePosition(self, newPosition=None):
+        if not self.media_player.is_playing():
+            return
+        if self.media_player.get_media() is None:
+            return
+        newPosition = self.positionSlider.sliderPosition()
+        self.media_player.set_position(float(newPosition)/float(TIME_RES))
+        
+        
+        
+    def updateInterface(self):
+        if not self.media_player.is_playing():
+            return
+        if self.media_player.get_media() is None:
+            return
+        a = self.media_player.get_position()
+        self.positionSlider.setValue(self.media_player.get_position()*TIME_RES)
+        

data/vendor/movie-content-editor-read-only/VideoMac.ui

@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>mainLayout</class>
+ <widget class="QWidget" name="mainLayout">
+  <property name="windowModality">
+   <enum>Qt::ApplicationModal</enum>
+  </property>
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>639</width>
+    <height>479</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="mouseTracking">
+   <bool>true</bool>
+  </property>
+  <property name="windowTitle">
+   <string/>
+  </property>
+  <property name="autoFillBackground">
+   <bool>true</bool>
+  </property>
+  <widget class="QPushButton" name="pauseButton">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>461</y>
+     <width>81</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Play/Pause</string>
+   </property>
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="flat">
+    <bool>false</bool>
+   </property>
+  </widget>
+  <widget class="QPushButton" name="stopButton">
+   <property name="geometry">
+    <rect>
+     <x>80</x>
+     <y>461</y>
+     <width>51</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Stop</string>
+   </property>
+   <property name="flat">
+    <bool>false</bool>
+   </property>
+  </widget>
+  <widget class="QSlider" name="positionSlider">
+   <property name="geometry">
+    <rect>
+     <x>140</x>
+     <y>462</y>
+     <width>451</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="sizePolicy">
+    <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+     <horstretch>1</horstretch>
+     <verstretch>0</verstretch>
+    </sizepolicy>
+   </property>
+   <property name="maximum">
+    <number>100</number>
+   </property>
+   <property name="orientation">
+    <enum>Qt::Horizontal</enum>
+   </property>
+  </widget>
+  <widget class="QWidget" name="verticalLayoutWidget">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>641</width>
+     <height>461</height>
+    </rect>
+   </property>
+   <layout class="QVBoxLayout" name="videoLayout"/>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

data/vendor/movie-content-editor-read-only/badwords.txt

@@ -0,0 +1,4 @@
+skills
+mouth
+Shashabooey
+Kablooey

data/vendor/movie-content-editor-read-only/blank.srt

@@ -0,0 +1,4 @@
+1
+00:00:35,702 --> 00:00:39,138
+
+

data/vendor/movie-content-editor-read-only/edit.py

@@ -0,0 +1,197 @@
+#! /usr/bin/python
+import vlc
+import sys
+import time
+from threading import Thread, Event
+from bisect import bisect
+from subtitle import readSrt
+from mergeCommands import merge
+
+DEBUG = True
+
+def sendDebug(msg, newline=1):
+    global DEBUG
+    if DEBUG:
+        if newline:
+            print ' '
+        print msg
+        
+@vlc.callbackmethod
+def playPauseCallback(event, data):
+    #do we need to do anything else here?
+    sendDebug('Got a callback')
+    thread1.event.set()
+    
+@vlc.callbackmethod
+def positionCallback(event, data):
+    #should probably do something here
+    thread1.event.set()
+    
+
+# For now I need to define the path, I commented out so it should work for you guys
+#path = 'C:\Users\cuff\Documents\moonlight\movie-content-editor\movie_editor\\'
+path = ''
+
+
+badwordsFile = "badwords.txt"
+movieFile = "Kung Fu Panda.m4v"
+subtitleFile = "panda.srt"
+blankFile = "blank.srt"
+customFile = "panda_custom.txt"
+
+# ------  create edited subtitle file ------
+subtitleEdit = readSrt(path,subtitleFile,badwordsFile)
+# --------------------------------------------
+
+# ------- create list of commands ----------
+commands = merge(path,customFile)
+# -----------------------------------------
+
+
+
+
+# -------- Load and start movie ----------------
+"""Set up the system independent movie interface. For windows, we can just use the 
+default Qt interface. For mac, we have to use our custom built interface. Nothing is
+currently implemented for Linux"""
+
+if sys.platform == 'darwin':
+    d='/Applications/VLC.app/Contents/MacOS'
+    args1 = "-I dummy --verbose=-1 --ignore-config --plugin-path="
+    if sendDebug:
+        args1 = "-I dummy --verbose=1 --ignore-config --plugin-path="
+    vlc_args = (args1 + d + "/modules --vout=minimal_macosx --opengl-provider=minimal_macosx")
+    instance = vlc.Instance(vlc_args)
+else:
+    instance = vlc.Instance()
+    instance.add_intf("qt")
+
+
+    
+media = instance.media_new(path + movieFile)
+player = instance.media_player_new()
+player.set_media(media)
+
+if sys.platform == 'darwin':
+    from PyQt4 import QtGui
+    from VLCMacVideo import MacPlayer
+    app = QtGui.QApplication(sys.argv)
+    mplayer = MacPlayer(player)
+
+events = vlc.EventType
+
+manager = player.event_manager()
+mediaManager = media.event_manager()
+manager.event_attach(events.MediaPlayerPaused,playPauseCallback,None)
+#manager.event_attach(events.MediaPlayerPausableChanged,dummy,None)
+manager.event_attach(events.MediaPlayerPlaying,playPauseCallback,None)
+#manager.event_attach(events.MediaPlayerTimeChanged,dummy,None)
+#mediaManager.event_attach(events.MediaStateChanged,dummy,None)
+manager.event_attach(events.MediaPlayerPositionChanged,positionCallback,None)
+player.play()
+# -------------------------------------------------
+
+# I use this for testing with Panda
+player.set_time(33000)
+
+
+
+# ------------- subclass off of Thread ---------------
+class editThread (Thread):
+    event = Event()    
+
+    def run ( self ):
+
+        sendDebug(commands)
+        #puts the keys in order - the keys are the time stamps of when the player state needs to change
+        sortedKeys = sorted(commands.keys())
+        sendDebug(sortedKeys)
+        currKey = 0.0
+        nextKey = 0.0
+        while True:
+            #if player isn't playing, wait for it to start
+            if not player.is_playing:
+                self.event.clear()
+                self.event.wait()
+                
+            #clear any old events so they don't continue to trigger a response                
+            self.event.clear()
+            
+            now = float(player.get_time())/1000.0
+
+            # find the correct portion of the timeline
+
+            # if we're actually at a new part of the timeline, then change the state
+            if not (currKey<= now <nextKey):
+                nextInd = bisect(sortedKeys,now)
+                nextKey = sortedKeys[nextInd]
+                sendDebug('New State')
+                currInd = nextInd - 1
+                currKey = sortedKeys[currInd]
+                sendDebug(currKey)    
+                
+                #Get the Playable and MuteOn attributes for the current state and act on them
+                Playable,MuteOn = commands[currKey]
+                if not Playable:
+                    skip(nextKey*1000)
+                    
+                if MuteOn:
+                    onMute()
+                else:
+                    offMute()
+
+
+
+            # wait for the next portion of the timeline, or for an user event to occur
+            # this is probably unnecessary because the PositionChanged event seems to occur
+            # every 0.5 s or so
+            waitTime = nextKey - float(player.get_time())/1000.0
+            if waitTime > 30.0:
+                self.event.wait(waitTime - 30.0)
+                waitTime = nextKey - float(player.get_time())/1000.0
+            self.event.wait(waitTime)
+                                
+                
+        return
+        
+# ------------------------------------------------------
+
+# ------- methods -------------------------
+def onMute ():
+    sendDebug("Muting started %s" % (float(player.get_time())/1000.0))
+    player.video_set_subtitle_file(path + subtitleEdit)
+    instance.audio_set_mute(1)
+    return
+    
+def offMute ():
+    sendDebug("Muting stopped %s" % (float(player.get_time())/1000.0))
+    player.video_set_subtitle_file(path + blankFile)
+#    player.video_set_spu("Testing SPU")
+    instance.audio_set_mute(0)
+    return
+
+def skip(tSkip):
+    sendDebug('Skipping ahead')
+    player.set_time(long(tSkip))
+    return
+
+def stop(player):
+    if sys.platform != 'darwin':
+        player.stop()
+    sys.exit()
+# --------------------------------------------
+
+thread1 = editThread()
+thread1.start()
+
+
+if sys.platform == 'darwin':
+    app.exec_()
+else:
+    # this is temporary just so player doesn't go on for long time
+    #time.sleep((80-player.get_time()/1000))
+    instance.wait()
+
+stop(player)
+
+