Merge lp:~nico-inattendu/luciole/bug_742343 into lp:luciole/0.8

[NicoInattendu]

Bug fixes :
    Bug #742343: luciole does not detect webcam on maverick
    Bug #782643: export to Pitivi always with same framerate
    Bug #871609: Framerate "not integer" provokes play failure

=== modified file 'lucioLib/lcl_export/lcl_export_pitivi.py'
--- lucioLib/lcl_export/lcl_export_pitivi.py	2010-01-03 14:10:07 +0000
+++ lucioLib/lcl_export/lcl_export_pitivi.py	2011-10-10 23:32:18 +0000
@@ -157,7 +157,8 @@
         """ compute duration in pitivi format. 
             Input is the fpi : number of frame per image
         """
-        duration = (1.0/fpi)*self.__BASE_DURATION_NS
+        print "export pitivi calc duration fpi = %s"%fpi
+        duration = (1.0/ (25.0/fpi) )*self.__BASE_DURATION_NS
         # use of str and int : int for a rounded value and str for string in element tree
         return str(int(duration))
 

=== modified file 'lucioLib/lcl_gst/lcl_gst_play.py'
--- lucioLib/lcl_gst/lcl_gst_play.py	2010-02-03 06:11:27 +0000
+++ lucioLib/lcl_gst/lcl_gst_play.py	2011-10-10 23:32:18 +0000
@@ -24,6 +24,7 @@
 import lcl_gst_base as LG
 
 
+import fractions
 
 class lcl_gst_play(LG.lcl_gstreamer) :
     """ implementation of image per image video playing with gstreamer .
@@ -34,7 +35,7 @@
           |_______________________________________________________________________________________________________|
       """
 
-    _filter_caps_string = "image/jpeg, framerate=(fraction)%s/1 ,width=360,height=288 "
+    _filter_caps_string = "image/jpeg, framerate=(fraction)%s ,width=360,height=288 "
     
     def _get_nbImages(self): return self._nbImages
     def _set_nbImages(self, value):
@@ -46,7 +47,7 @@
     def _get_framerate(self): return self._framerate
     def _set_framerate(self, value):
         if isinstance(value, str) and self.ImageFilter :
-            caps_string = self._filter_caps_string % value
+            caps_string = self._filter_caps_string % (fractions.Fraction(value))
             caps = LG.Caps(caps_string)
             self.ImageFilter.set_property("caps", caps)
             self._framerate = value   

=== modified file 'lucioLib/lucioWebCamDetect/luciole_webcam_detection.py'
--- lucioLib/lucioWebCamDetect/luciole_webcam_detection.py	2010-02-03 06:11:27 +0000
+++ lucioLib/lucioWebCamDetect/luciole_webcam_detection.py	2011-10-10 23:32:18 +0000
@@ -4,7 +4,7 @@
 # vim:si:ai:et:sw=4:sts=4:ts=4
 #
 #
-# Copyright Nicolas Bertrand ([e-mail]), 2009-2010
+# Copyright Nicolas Bertrand ([e-mail]), 2009-2011
 #
 # This file is part of Luciole.
 #
@@ -22,59 +22,93 @@
 #    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
 #
 #
-
-import dbus
-import dbus.glib
-import sys
-import os
-import fcntl
-
+"""
+luciole_webcam_detection 
+Interface function for webcam detection.
+Retro compatibilty of luciole 0.9 in 0.8 branch.
+Main reason : remove usage of hal
+"""
+import gobject
 import gst
 
-import time
-
-import gobject
 
 import logging 
 module_logger = logging.getLogger('luciole')
 
+#from lucioLib.luciole_exceptions import luciole_exceptions as LEXCEP
 
 from .. import luciole_exceptions as LEXCEP
-
-
-# Availables video sources for gstreamer
-GSTREAMER_VIDEO_SOURCES = [
-    "v4l2src",
-    "v4lsrc"
-  ]
-
-
-class luciole_webcam_detection(object) :
-    """ class in charge of detection of available webcams """
-
-    def __get_webcam_devices(self) : return self._webcam_devices
-    webcam_devices = property(__get_webcam_devices, None, None, "webcam devices description")
+#import luciole_exceptions as LEXCEP
+
+
+from webcam_detection import WebcamDetection
+
+class luciole_webcam_detection(WebcamDetection) :
 
     def __init__(self) :
-        """ class init"""
-        # init logger
-        self.logger = logging.getLogger('luciole')
-        
-        self._webcam_devices = list()
-    
-    ############################################################
-    ### PUBLIC METHODS
-    ############################################################
-    def detect_webcam(self) :
-        """ performs webcam detection . 
-            returns number of webcam detected 
-        """
-        status = self._hal_detection()
-        if status != 0 :
-            # at least webcam was found , perform gstremer detection 
-            status = self._gst_detection()
-    
-        return status
+        WebcamDetection.__init__(self)
+
+    def detect_webcam(self):
+        """ interface function for webcam detection """
+        # udev detetction
+        _nb_webcams = WebcamDetection.detect_webcams(self)
+        
+        if _nb_webcams != 0 :
+             # detect properties with gstreamer
+            self.gst_props =  webcam_gstreamer_properties(self.webcam_devices)
+            _nb_webcams = self.gst_props.gst_detection()
+
+        return _nb_webcams
+    
+    def get_gst_best_input(self, webcam_device_index=0) :
+        """ interface function to select best input """
+        return self.gst_props.get_gst_best_input(webcam_device_index)
+        #_device = self.webcam_devices[webcam_device_index]
+        #print "device ", _device
+        #_prop_name ='definition'
+        
+        
+        #WebcamDetection.get_best_value(self, _prop_name, "")
+
+
+class webcam_gstreamer_properties(object) :
+    
+    def __init__(self, devices) :
+        self._webcam_devices = devices
+        # laucnch gst detection
+
+    
+
+    def gst_detection(self) :
+        """ performs webcam type detection with gstreamer :
+            _ detects what source yo use ( v4lsrc or v4l2src)
+            _ resolution 
+            _ video mime types
+        """ 
+        nb_device_detected = 0
+        for webcam_device in self._webcam_devices :
+            # for each detected device get the data (source type, mimetype, resolution) 
+            (status, webcam_device_data) = self.__get_gst_webcam_data(webcam_device["device-file"], webcam_device["v4ldriver"])
+            if status[0] == gst.STATE_CHANGE_SUCCESS and webcam_device_data != None :  
+                # detection is success
+                webcam_device["webcam_data"] = webcam_device_data
+                nb_device_detected = nb_device_detected +1
+            else :
+                # gstreamer test unsuccesfull : test with other driver
+                if webcam_device["v4ldriver"] == 'v4lsrc' :
+                    webcam_device["v4ldriver"] = 'v4l2src'
+                else :
+                    webcam_device["v4ldriver"] ='v4lsrc'
+                (status, webcam_device_data) = self.__get_gst_webcam_data(webcam_device["device-file"], webcam_device["v4ldriver"])
+                if status[0] == gst.STATE_CHANGE_SUCCESS and webcam_device_data != None :  
+                    # detection is success
+                    webcam_device["webcam_data"] = webcam_device_data
+                    nb_device_detected = nb_device_detected +1
+                else :
+                    #Nothing detected . Reset webcam device
+                    webcam_device=dict()
+        return nb_device_detected
+
 
     def get_gst_best_input(self, webcam_device_index=0) :
         """ for selected webcam device returns the gst.Bin with  
@@ -100,10 +134,11 @@
             if video_formats.has_key(mimetype) :
                 # the resolution format are sorted by resolution  
                 # the higher resolution is first in list
-                width = video_formats[mimetype][0]['width']
-                height = video_formats[mimetype][0]['height']
-                framerate =  video_formats[mimetype][0]['framerate']
-
+                
+                #width = video_formats[mimetype][0]['width']
+                #height = video_formats[mimetype][0]['height']
+                #framerate =  video_formats[mimetype][0]['framerate']
+                width, height, framerate = self._get_best_definition(video_formats[mimetype])
                 
                 # leave loop when mimetype is found
                 break
@@ -114,113 +149,30 @@
             webcam_bin_data['height'] = height
             webcam_bin_data['framerate_list'] = framerate
             webcam_bin_data['framerate_selected'] = framerate[len(framerate)/2]
-            webcam_bin_data['source_input'] = self._webcam_devices[webcam_device_index]['v4l_driver']
-            webcam_bin_data['device'] = self._webcam_devices[webcam_device_index]['device'] 
+            webcam_bin_data['source_input'] = self._webcam_devices[webcam_device_index]['v4ldriver']
+            webcam_bin_data['device'] = self._webcam_devices[webcam_device_index]['device-file'] 
             webcam_bin_data['name'] = self._webcam_devices[webcam_device_index]['name']
 
         return  webcam_bin_data
 
-            
-            
-               
-
-    ############################################################
-    ### PRIVATE METHODS
-    ############################################################
-
-    def _hal_detection(self) :
-        """ performs hal detection """
-    
-        # get a connection to the system bus
-        bus = dbus.SystemBus ()
-
-        # get a HAL object and an interface to HAL to make function calls
-        hal_obj = bus.get_object ('org.freedesktop.Hal', '/org/freedesktop/Hal/Manager')
-        hal = dbus.Interface (hal_obj, 'org.freedesktop.Hal.Manager')
-
-        # find all devices that have the capability 'video4linux'
-        udis = hal.FindDeviceByCapability ('video4linux')
-        
-        # loop on found device 
-        for udi in udis :
-            webcam_device = dict()
-            
-            # get a device object
-            dev_obj = bus.get_object ('org.freedesktop.Hal', udi)
-            
-            # get an interface to the device
-            dev = dbus.Interface (dev_obj, 'org.freedesktop.Hal.Device')
-            
-            
-            webcam_device["name"] = dev.GetProperty ('info.product')
-            if webcam_device["name"] == None : webcam_device["name"] = "Unknown"
-            webcam_device["device"] = dev.GetProperty ('video4linux.device')
-        
-            # detect if need to use v4lsrc or v4l2sec ; property :video4linux.version
-            #  for robustness if version = 1 , than use v4lsrc else use v4l2src 
-            version = dev.GetProperty ('video4linux.version')
-            # default is v4l2src
-            webcam_device['v4l_driver'] = 'v4l2src'
-            if version != None and int(version) == 1 :
-                webcam_device['v4l_driver'] = 'v4lsrc'
-            
-
-            if (not  webcam_device["device"] == None) and ( self.__is_device_readable(webcam_device["device"]) ) :
-                self._webcam_devices.append(webcam_device)
-       
-        # the function returns the number of device found.
-        nb_device_found = 0
-        if not self._webcam_devices == None :
-            nb_device_found = len(self._webcam_devices)
-
-        return nb_device_found
-
-    def _gst_detection(self) :
-        """ performs webcam type detection with gstreamer :
-            _ detects what source yo use ( v4lsrc or v4l2src)
-            _ resolution 
-            _ video mime types
-        """ 
-        nb_device_detected = 0
-        for webcam_device in self._webcam_devices :
-            # for each detected device get the data (source type, mimetype, resolution) 
-            (status, webcam_device_data) = self.__get_gst_webcam_data(webcam_device["device"], webcam_device["v4l_driver"])
-            if status[0] == gst.STATE_CHANGE_SUCCESS and webcam_device_data != None :  
-                # detection is success
-                webcam_device["webcam_data"] = webcam_device_data
-                nb_device_detected = nb_device_detected +1
-            else :
-                # gstreamer test unsuccesfull : test with other driver
-                if webcam_device["v4l_driver"] == 'v4lsrc' :
-                    webcam_device["v4l_driver"] = 'v4l2src'
-                else :
-                    webcam_device["v4l_driver"] ='v4lsrc'
-                (status, webcam_device_data) = self.__get_gst_webcam_data(webcam_device["device"], webcam_device["v4l_driver"])
-                if status[0] == gst.STATE_CHANGE_SUCCESS and webcam_device_data != None :  
-                    # detection is success
-                    webcam_device["webcam_data"] = webcam_device_data
-                    nb_device_detected = nb_device_detected +1
-                else :
-                    #Nothing detected . Reset webcam device
-                    webcam_device=dict()
-        return nb_device_detected
-            
-
-    ############################################################
-    ### PRIVATE STATIC METHODS
-    ############################################################
-    def __is_device_readable(device) :
-        """ check if device is readable """
-        is_readable = False
-        try :
-            fd = open(device,'r')
-        except IOError,err:
-            is_readable = False
-        else :
-            is_readable = True
-            fd.close()
-        return is_readable
-    __is_device_readable = staticmethod(__is_device_readable)
+ 
+    def _get_best_definition(self, mimetype_data) :
+        """ Loop on width height return valu with greatest size ( Widthxheight)"""
+        _width = 0
+        _height = 0
+        _MAX = _width * _height
+        _framerate = 0
+        for _data in mimetype_data :
+            _new_max = _data['width'] * _data['height']
+            if _new_max > _MAX :
+                _MAX = _new_max
+                _width = _data['width']
+                _height = _data['height']
+                _framerate =  _data['framerate']
+        return _width, _height, _framerate
+
+
+
 
     def __get_gst_webcam_data(device_name,driver) :
         """ get data from the webcam test compatible sources
@@ -250,7 +202,7 @@
             # of the source "src" pad 
             pad = src.get_pad("src")
             caps = pad.get_caps()
-            luciole_webcam_detection.gst_get_supported_video_formats(webcam_device,caps)
+            webcam_gstreamer_properties.gst_get_supported_video_formats(webcam_device,caps)
             # stop playing with webcam
             pipeline.set_state(gst.STATE_NULL)
         return (ret,webcam_device)
@@ -314,7 +266,7 @@
                         (resolution["width"] , resolution["height"] ) = (structure["width"],structure["height"])  
                         resolution["framerate"] = None
                         if structure.has_field("framerate") :
-                            resolution["framerate"] = luciole_webcam_detection.gst_get_framerate(structure["framerate"])
+                            resolution["framerate"] = webcam_gstreamer_properties.gst_get_framerate(structure["framerate"])
                         if not resolution  in resolution_list :
                             resolution_list.append(resolution)
                     
@@ -367,6 +319,9 @@
         return framerate_trans
     gst_get_framerate = staticmethod(__gst_get_framerate)
 
+
+
+    
 if __name__ == '__main__' :
     # TEST PURPOSE  : for webcam detection
     CamObj = luciole_webcam_detection()
@@ -376,7 +331,7 @@
     #if val >0 :
     #    for device in CamObj.webcam_devices : 
     #        for k,j in device.iteritems() : print "%s : %s"%(k,j)
-    #        print "----------------------------------------------------------------"
+    #        print "---------------------------------------------"
     for i in range(val) :
     #for enumerate(index,device) in CamObj.webcam_devices :
         best = CamObj.get_gst_best_input(i)

=== added file 'lucioLib/lucioWebCamDetect/webcam_detection.py'
--- lucioLib/lucioWebCamDetect/webcam_detection.py	1970-01-01 00:00:00 +0000
+++ lucioLib/lucioWebCamDetect/webcam_detection.py	2011-10-10 23:32:18 +0000
@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -*- Mode: Python -*-
+# vim:si:ai:et:sw=4:sts=4:ts=4
+#
+#
+# Copyright Nicolas Bertrand ([e-mail]), 2009-2010
+#
+# This file is part of Luciole.
+#
+#    Luciole is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Luciole 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 General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Luciole.  If not, see <http://www.gnu.org/licenses/>.
+#
+#
+"""
+    webcam_detection.py :
+    Webcam detection module
+"""
+import gudev
+import glib
+
+import gst
+
+
+
+class WebcamDetection(object) :
+
+    def _get_webcam_devices(self) : 
+        """ getter for webcam_devices"""
+        return self._webcam_devices
+    webcam_devices = property(  _get_webcam_devices,
+                                None,
+                                None,
+                                "webcam devices description")
+
+    def __init__(self) :
+        """ class init"""
+        
+        self._webcam_devices = []
+    
+    def detect_webcams(self) :
+        client = gudev.Client(["block", "usb"])
+        devices = client.query_by_subsystem("video4linux")
+        self.device_information(devices)
+
+        return len(self._webcam_devices)
+
+    def device_information(self, devices) :
+        
+        for _device in devices :
+            _device_desc = {}
+            _device_desc['device-file'] = _device.get_device_file()
+            
+            _v4lversion = self._get_prop(_device, 'ID_V4L_VERSION')
+            print type(_v4lversion)
+            
+            if int(_v4lversion) in (1, 2) :
+                # getting information related to v4l
+                if _v4lversion == 1 : 
+                    _device_desc['v4ldriver'] = 'v4lsrc'
+                else :
+                    _device_desc['v4ldriver'] = 'v4l2src'
+             
+                _device_desc['name'] = self._get_prop(_device, 'ID_V4L_PRODUCT')
+                if not ':capture:' in self._get_prop(_device, "ID_V4L_CAPABILITIES") :
+                    self.error('Device %s seems to not have the capture capability',
+                            _device_desc['device-file'])
+                    continue
+            else :
+                self.error(
+                    "Fix your udev installation to include v4l_id, ignoring %s",
+                    _device_desc['device-file'])
+                continue
+            # append selected element
+            self._webcam_devices.append(_device_desc)
+
+            
+
+    def _get_prop(self, device, key_p) :
+        _val = "UNKNOW_%s" % key_p
+        if device.has_property(key_p) :
+            _val = device.get_property(key_p)
+        return _val
+
+   
+
+if __name__ == '__main__' :
+    
+    CamDetect = WebcamDetection()
+    _nb = CamDetect.detect_webcams()
+    print "Find %s devices"% _nb  
+    for _cam in CamDetect.webcam_devices :
+        print _cam
+
+