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

[NicoInattendu]

Merge with corrections fo excessive CPU bug #500649

[NicoInattendu (nico-inattendu)]

Merge with 0.8

Translation update needed after

[NicoInattendu (nico-inattendu)]

review: Approve

=== modified file 'lucioLib/gui/dialog_project_properties.py'
--- lucioLib/gui/dialog_project_properties.py	2009-04-28 13:36:55 +0000
+++ lucioLib/gui/dialog_project_properties.py	2010-01-29 07:10:30 +0000
@@ -1,9 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # -*- Mode: Python -*-
-# vi:si:ai:et:sw=4:sts=4:ts=4
+# vim:si:ai:et:sw=4:sts=4:ts=4
 #
-# Copyright Nicolas Bertrand ([e-mail]), 2009
+# Copyright Nicolas Bertrand ([e-mail]), 2009, 2010
 #
 # This file is part of Luciole.
 #
@@ -22,16 +22,22 @@
 #
 #
 """
-    dialog_project_properties.py : Dialog who display the project properties
+    dialog_project_properties.py : Dialog who display the luciole project properties
 """
+#i18n
 from gettext import gettext as _
+
 import gtk
 import pango
 
 from .. import luciole_constants as LCONST
 import webcam_detection_widget as LWDW
 
-(LABEL,ENTRY)=range(2)
+
+#type of widgets for displaying webcam data
+(LABEL,ENTRY,SCALE)=range(3)
+
+
 
 class Project_properties(object):
    
@@ -83,14 +89,19 @@
                                 'desc' : _('Video height :'),
                                 'type'  :   LABEL
                                 },
+            'framerate_list':     {    
+                                'desc' : _('Webcam framerate \n (number of images per second)'),
+                                'type'  :   SCALE
+                                },
+
+ 
         }
 
 
     _title = _('Project properties')
     
     def __init__(self,main_window,  project, cb_project_change) :
-        """ create a Dialog with project properties and disqpay it"""
-
+        """ create a Dialog with project properties and display it"""
         self._dialog = gtk.Dialog   (   _(self._title),
                                         main_window,
                                         gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
@@ -101,6 +112,9 @@
         self._project = project
         self._cb_project_change = cb_project_change
         
+        # keep framerate list and framerate selected those value can change
+        self._framerate_selected = self._project['webcam_data']['framerate_selected']
+        self._framerate_list = self._project['webcam_data']['framerate_list']
         # connect destroy signal
         #self._dialog.connect("destroy", self._cb_on_exit)
         self._dialog.connect("delete-event", self._cb_on_exit)
@@ -131,10 +145,19 @@
                 # assumption only enry on webcam data
                 webcam_dict = self._project['webcam_data']
                 for (key_entry, widget_entry) in self.webcam_widgets.iteritems() :
-                    if widget_entry.get_text() !=  webcam_dict[key_entry] :
-                        # entry value changed
-                        # emit callback to inidcate project change
-                        self._cb_project_change('webcam_data', key_entry, widget_entry.get_text())
+                    # specific treatment when the wigdet is associated to framerate_list
+                    # store framerate_list and framerate_selected
+                    if key_entry == 'framerate_list' :
+                        # callback for updated framerate
+                        self._cb_project_change('webcam_data', 'framerate_selected',self._framerate_selected)
+                        # check if framerate list has changed if yes callback for framerate list
+                        if  webcam_dict[key_entry] != self._framerate_list :
+                            self._cb_project_change('webcam_data', 'framerate_list',self._framerate_list)
+                    else :
+                        if widget_entry.get_text() !=  webcam_dict[key_entry] :
+                            # entry value changed
+                            # emit callback to inidcate project change
+                            self._cb_project_change('webcam_data', key_entry, widget_entry.get_text())
     
     def _cb_on_exit(self,widget,event) :
         self._dialog.destroy()
@@ -196,15 +219,19 @@
         widget = None
         if self._WEBCAM_PREFS[key]['type'] == ENTRY :
             widget = gtk.Entry()
-            widget.set_alignment(xalign=0.0)    # left justification of label
-        else: 
+            widget.set_alignment(xalign = 0.0)                 # left justification 
+            widget.set_text("%s"%self._project['webcam_data'][key])
+        elif self._WEBCAM_PREFS[key]['type'] == LABEL : 
             widget = gtk.Label()
-            widget.set_alignment(xalign=0.0,yalign=0.5)    # left justification of label
-        
+            widget.set_alignment(xalign = 0.0, yalign = 0.5)     # left justification 
+            widget.set_text("%s"%self._project['webcam_data'][key])
+        elif self._WEBCAM_PREFS[key]['type'] == SCALE :
+            widget = Framerate_scale(self._project['webcam_data'][key],
+                                    self._project['webcam_data']['framerate_selected'],
+                                    self._cb_framerate_selected)
+
         self.webcam_widgets[key] = widget     # save the widget
         
-        widget.set_text("%s"%self._project['webcam_data'][key])
-
         widget.show()
         table.attach(widget, 1, 2, row, row+1,xpadding = 10 )
 
@@ -235,7 +262,9 @@
             self.make_table_webcam_row(table,2,'height')
             self.make_table_webcam_row(table,3,'source_input')
             self.make_table_webcam_row(table,4,'device')
-            
+            self.make_table_webcam_row(table,5,'framerate_list')
+            # No lines for framerate_selected tag : handled framerate_list tag
+
             Hbox.pack_start(   child = table,
                                 expand = True,
                                 fill =  True,
@@ -294,15 +323,25 @@
 
 
     def _cb_webcam_detection(self,project_data) :
-        """ calback when webcam detection is done update webcam data """
+        """ callback when webcam detection is done update webcam data """
         if project_data.has_key('webcam_data') and project_data['webcam_data'] != {} :
             for (w_key, w_widget) in self.webcam_widgets.iteritems() :
-                if  project_data['webcam_data'].has_key(w_key) : 
-                    w_text ="%s"%project_data['webcam_data'][w_key]
-                    w_widget.set_text(w_text)
+                # Sepcific operation for framerate_list widget
+                if w_key == 'framerate_list' :
+                    w_widget.refresh(project_data['webcam_data']['framerate_list'],
+                                    project_data['webcam_data']['framerate_selected'] )
+                    self._framerate_list = project_data['webcam_data']['framerate_list']
+                # for other webcam widgets : only text to update
                 else :
-                    w_widget.set_text('')
-
+                    if  project_data['webcam_data'].has_key(w_key) : 
+                        w_text ="%s"%project_data['webcam_data'][w_key]
+                        w_widget.set_text(w_text)
+                    else :
+                        w_widget.set_text('')
+    
+    def _cb_framerate_selected(self,framerate) :
+        """ callback to update selected framerate used by Framerate_scale widget """
+        self._framerate_selected = framerate
 
 class Webcam_detection_dialog(gtk.MessageDialog) :
     """ Opens Dialog for webcam Detection """
@@ -352,4 +391,107 @@
         return True
 
 
-
+class Framerate_scale(gtk.HScale) :
+    """ 
+    Widget use to display an horizontal scale : 
+    represenation of webcam framerates  in number of images per seconds
+    """
+    
+    def __init__(self,framerate_range,initial_range,cb_framerate_changed) :
+        """
+            Constructor
+            params :
+                - framerate_range : The framerate range - a list of framerate tuple
+                - initial_range : The initial range to dipslay - a tuple
+                - cb_framerate_changed : the callback function to indicate framerate change
+        """
+        
+        # 
+        # store params
+        #
+        self._framerate_range = framerate_range
+        self._initial_range = initial_range
+        self._cb_framerate_changed = cb_framerate_changed
+
+        
+        #
+        # configure widget
+        #
+        
+        # compute the initial position on Scale bar
+        initial_f_value = float(self._framerate_range.index(self._initial_range))
+        
+        #
+        # compute an adjustment in range [0 .. nb_framerate], icrement is 1 
+        # Use floats as ints actually
+        # Display framerates instead of float values
+        # 
+        adj = gtk.Adjustment(value =initial_f_value, 
+                            lower = 0.0, 
+                            upper = float(len( self._framerate_range)),
+                            step_incr = 1.0,
+                            page_incr = 1.0)
+
+        
+        super(Framerate_scale,self).__init__(adjustment = adj)
+        
+        # configure signals
+        self.connect("format-value", self.on_format_value)
+        self.connect("value-changed", self.on_value_changed)
+        
+        # configure widget display properties
+        self.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
+        self.set_value_pos(gtk.POS_BOTTOM)
+        self.show_all()
+
+    def on_format_value(self,widget,value) :
+        """
+        Signal 'format-value' : Used to display value in scale in image/seconds format.
+        Computed according the adjustment value,  the intger round of value is the index
+        of framerate_range
+        """
+        int_val = int(value)
+        if int_val >= len(self._framerate_range) :
+            int_val = len(self._framerate_range) -1
+        val_to_display = self._framerate_range[int_val]
+        # compute and return the number of images per second
+        return int(val_to_display[0]/val_to_display[1])
+ 
+    def on_value_changed(self,widget) :
+        """ 
+        Emited when a value is changed and selected by user 
+        the signal function get the float value, round it, 
+        get the equivalent framerate. 
+        """ 
+        # TODO : how to update webcam date
+        
+        # get rounded value
+        int_val = int(widget.get_value())
+        if int_val >= len(self._framerate_range) :
+            int_val = len(self._framerate_range) -1
+        # update project data : do callback call
+        self._cb_framerate_changed( self._framerate_range[int_val])
+
+
+    def refresh(self, framerate_list, framerate_selected) :
+        """
+        Update Scale bar and ajustment according new framerate range
+        """
+
+        self._framerate_range = framerate_list
+        self._initial_range = framerate_selected
+        
+        #
+        # recompute adjustment
+        #
+        initial_f_value = float(self._framerate_range.index(self._initial_range))
+
+        adj = gtk.Adjustment(value =initial_f_value, 
+                            lower = 0.0, 
+                            upper = float(len( self._framerate_range)),
+                            step_incr = 1.0,
+                            page_incr = 1.0)
+
+        self.set_adjustment(adj)
+
+    
 
=== modified file 'lucioLib/lcl_gst/lcl_gst_acq.py'
--- lucioLib/lcl_gst/lcl_gst_acq.py	2009-12-14 06:15:44 +0000
+++ lucioLib/lcl_gst/lcl_gst_acq.py	2010-01-29 07:10:30 +0000
@@ -40,12 +40,28 @@
 
 class PhotoSaveBin(LG.Bin) :
     """ Bin Pad to save in jpeg format image from stream. Stream alyays encoded but the result will be saved to file only when a capture is done """
+    
+    # Do jpeg encoding with a framerate of 5 images per second used to reduce cpu
+    JPEG_CAPS_FILTER =  " video/x-raw-yuv, framerate=5/1 "
+    
     def __init__(self) :
         """ Pilpeline desc : jpegenc + fakseink """
 
+        super(PhotoSaveBin,self).__init__()
         self.__gobject_init__()
         ImageBinElems=[]
         
+        Myvideorate = LG.element_factory_make('videorate')                    #  rate transformation
+        ImageBinElems.append(Myvideorate)
+
+        MyJpegFilter = LG.element_factory_make("capsfilter", "JpegFilter")
+        # create caps string according, width, height and framerate
+        caps = LG.Caps(self.JPEG_CAPS_FILTER)
+
+        self.logger.info(" Webcam cap : %s"%caps.to_string())
+        MyJpegFilter.set_property("caps", caps)
+        ImageBinElems.append(MyJpegFilter)
+
         MyJpegenc = LG.element_factory_make("jpegenc","MyJpegenc")                 # jpeg encoding
         ImageBinElems.append(MyJpegenc)   
         
@@ -54,9 +70,9 @@
         
         for elem in ImageBinElems : self.add(elem)
         
-        LG.element_link_many(MyJpegenc,photosink)
+        LG.element_link_many(Myvideorate,MyJpegFilter,MyJpegenc,photosink)
         
-        self.add_pad(LG.GhostPad('sink', MyJpegenc.get_pad('sink')))
+        self.add_pad(LG.GhostPad('sink', Myvideorate.get_pad('sink')))
 
 
 class InputImageBin(LG.Bin):
@@ -79,7 +95,7 @@
         self.MyAlpha.set_property("alpha",self.__alphaValueImage)    
     alphaValueImage = property(get_alphaValueImage, set_alphaValueImage, None, " Framerate for displaying input image ")
 
-    def __init__(self,image,alphaValue,framerate=25) :
+    def __init__(self,image,alphaValue,framerate=1) :
         self.__gobject_init__()
         self.__image2Mix = image
         self.__framerate =  framerate
@@ -90,11 +106,12 @@
         self.InputImage= LG.element_factory_make('multifilesrc')
         self.InputImage.set_property('location',self.__image2Mix)
         ImageBinElems.append(self.InputImage)
-        
+       
+
         # filter to set frame rate
         self.ImageFilter = LG.element_factory_make("capsfilter")
         self._filter_caps_string = "image/jpeg, framerate=(fraction)%s/1 ,width=%s,height=%s "
-
+        
         caps_string = self._filter_caps_string%(self.__framerate,MCONST.VIDEO_PAL_RES[0],MCONST.VIDEO_PAL_RES[1])
         caps = LG.Caps(caps_string)
         self.ImageFilter.set_property("caps", caps)
@@ -282,16 +299,22 @@
 
 class WebcamInputBin(LG.Bin) :
     """ LG.Bin for Web cam input"""
-    def __init__(self,width=640,height=480,source_input='v4l2src',device='/dev/video0') :
-        """build Dv cam input bin
+    def __init__(self,width=640, height=480, framerate=(2,25), source_input='v4l2src', device='/dev/video0') :
+        """build web cam input bin
         Description of pipeline : 
                __________________________________________________________
               |                                                          | 
         -->-- | v4lsrc -->  capsfilter --> ffmpegcolorspace --> ScaleBin | ghostPad -->--
               |__________________________________________________________|_ 
-         
+        params :
+            width :         The webcam width. Integer value
+            height :        The webcam width. Integer value
+            framerate :     The webcam framerate. A tuple for fraction representation (denom,num)
+            source_input :  The type of driver input. A string
+            device :        Path to webcam device. A string 
+
         """
-
+        super(WebcamInputBin,self).__init__()
         self.__gobject_init__()
         ImageBinElems=[]
           
@@ -300,8 +323,9 @@
         ImageBinElems.append(MyVideoSrc)
         
         MyVideoSrcFilter = LG.element_factory_make("capsfilter", "MyVideoSrc")
-
-        caps = LG.Caps("video/x-raw-yuv, width=%s,height=%s"%(width,height) )
+        # create caps string according, width, height and framerate
+        caps = LG.Caps("video/x-raw-yuv, width=%s,height=%s , framerate=%s/%s "%(width,height,framerate[0],framerate[1]) )
+        self.logger.info(" Webcam cap : %s"%caps.to_string())
         MyVideoSrcFilter.set_property("caps", caps)
         ImageBinElems.append(MyVideoSrcFilter)
         
@@ -492,6 +516,8 @@
         self.__webcam_data['height'] = 480
         self.__webcam_data['device'] = "/dev/video0"
         self.__webcam_data['source_input'] = "v4l2src"
+        self.__webcam_data['framerate_list'] = [ (25,2) ] 
+        self.__webcam_data['framerate_selected'] = (25,2) 
 
     def reset_pipe(self): 
         """ Gstreamer pipe configuration :
@@ -500,10 +526,14 @@
         """
         ElementList = []
         self.pipe = LG.Pipeline(self.pipe_name)
+        print self.__webcam_data
+        print " type framerate list :" , type(self.__webcam_data['framerate_list'])
+
         if (self.__inputType == MCONST.WEBCAM) :
             InputBin = WebcamInputBin(
                         width = self.__webcam_data['width'],
                         height = self.__webcam_data['height'],
+                        framerate = self.__webcam_data['framerate_selected'],
                         source_input = self.__webcam_data['source_input'],
                         device = self.__webcam_data['device']
                         )
 
=== modified file 'lucioLib/lcl_gst/lcl_gst_base.py'
--- lucioLib/lcl_gst/lcl_gst_base.py	2009-12-14 06:15:44 +0000
+++ lucioLib/lcl_gst/lcl_gst_base.py	2010-01-29 07:10:30 +0000
@@ -60,11 +60,19 @@
 #
 
 class Pipeline(gst.Pipeline) :
-    """ Interaface class for pipeline """
+    """ Interface class for gst pipeline """
 
     def __init__(self, *args,**kwargs) :
         super(Pipeline, self).__init__(*args,**kwargs)
 
+class Bin(gst.Bin) :
+    """ Interface class for gst Bin  """
+    
+    def __init__(self, *args,**kwargs) :
+        super(Bin, self).__init__(*args,**kwargs)
+        self.logger = logging.getLogger('luciole')
+
+
 class VideoWidget(object):
     """ class usage to be understood """    
     def __init__(self,DrawingArea):
@@ -91,11 +99,7 @@
 
     def __init__(self,video_widget = None, pipe_name=None, cb_on_error = None, cb_on_eos = None ):
         # init logger
-
         self.logger = logging.getLogger('luciole')
-        if self.logger.level == logging.DEBUG :
-            gst.debug_set_active(True)
-            gst.debug_set_default_threshold(gst.LEVEL_DEBUG)
     
         #
         # link display window widget with gstreamer 
@@ -109,7 +113,7 @@
         self._cb_on_eos = cb_on_eos
         
         self.pipe = Pipeline(pipe_name)
-        print self.pipe
+        self.logger.info(self.pipe)
         
     def connect_bus(self) :
         """ Connect to bus """
 
=== modified file 'lucioLib/lcl_gst/lcl_gst_play.py'
--- lucioLib/lcl_gst/lcl_gst_play.py	2009-12-14 06:15:44 +0000
+++ lucioLib/lcl_gst/lcl_gst_play.py	2010-01-29 07:10:30 +0000
@@ -83,7 +83,6 @@
         # filter
         self.ImageFilter = LG.element_factory_make("capsfilter")
         caps_string = self._filter_caps_string % self._framerate
-        print caps_string
         caps = LG.gst.Caps(caps_string)
         self.ImageFilter.set_property("caps", caps)
         ElementList.append(self.ImageFilter)
 
=== modified file 'lucioLib/lucioWebCamDetect/luciole_webcam_detection.py'
--- lucioLib/lucioWebCamDetect/luciole_webcam_detection.py	2009-05-09 16:11:31 +0000
+++ lucioLib/lucioWebCamDetect/luciole_webcam_detection.py	2010-01-29 07:10:30 +0000
@@ -35,6 +35,12 @@
 
 import gobject
 
+import logging 
+module_logger = logging.getLogger('luciole')
+
+
+from .. import luciole_exceptions as LEXCEP
+
 
 # Availables video sources for gstreamer
 GSTREAMER_VIDEO_SOURCES = [
@@ -51,6 +57,9 @@
 
     def __init__(self) :
         """ class init"""
+        # init logger
+        self.logger = logging.getLogger('luciole')
+        
         self._webcam_devices = list()
     
     ############################################################
@@ -86,13 +95,15 @@
         video_formats = self._webcam_devices[webcam_device_index]['webcam_data']['video_formats']         
         mimetypes = ('video/x-raw-yuv','video/x-raw-rgb','image/jpeg')
         (width,height)=(None,None)
-
         for mimetype in mimetypes :
+
             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']
+
                 
                 # leave loop when mimetype is found
                 break
@@ -101,9 +112,11 @@
             # a format was detected : prepare pipeline info
             webcam_bin_data['width'] = width 
             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['name'] = self._webcam_devices[webcam_device_index]['name'] 
+            webcam_bin_data['name'] = self._webcam_devices[webcam_device_index]['name']
 
         return  webcam_bin_data
 
@@ -262,7 +275,6 @@
         for i in range(num_structures) :
             # loop on each strutcures
             structure = caps[i]
-            
             if (    structure.has_name("video/x-raw-yuv") 
                 or  structure.has_name("video/x-raw-rgb")  
                 or  structure.has_name("image/jpeg")
@@ -271,12 +283,12 @@
                 if not webcam_device["video_formats"].has_key(structure.get_name()):
                     webcam_device["video_formats"][structure.get_name()] = list()
                 resolution_list = webcam_device["video_formats"][structure.get_name()]
-                #print " resolution_list at the begin : %s"%webcam_device["video_formats"]
+                #print " resolution_list at the begin : \n %s"%webcam_device["video_formats"]
                 
                 # take in acount only structure wih fields width and height
                 if (structure.has_field("width") and  structure.has_field("height")) :
                     #print "  %s : %s x %s"%(structure.get_name(),structure["width"],structure["height"] )
-                    
+                    resolution=dict()
                     # check if result is in GST_TYPE_INT_RANGE format
                     if (isinstance(structure["width"], gst.IntRange)):
                         # when type is range --> some resolution points are created in the range
@@ -286,21 +298,31 @@
                         while ( ( width_cur   <=  structure["width"].high ) and
                               ( height_cur  <=  structure["height"].high ) 
                             ):
-                            resolution=dict()
+                            
                             ( resolution["width"] , resolution["height"] ) = (width_cur,height_cur)  
+                            #store framerate 
+                            resolution["framerate"] = None
+                            if structure.has_field("framerate") :
+                                resolution["framerate"] = structure["framerate"]
+                            # Append resolution dict to list
                             if not resolution  in resolution_list :
                                 resolution_list.append(resolution)
                             (width_cur,height_cur) = (width_cur*2,height_cur*2)
                     
                     # check if result is in G_TYPE_INT format
                     elif  structure.has_field_typed("width",gobject.TYPE_INT) :
-                        resolution=dict()
                         (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"])
                         if not resolution  in resolution_list :
                             resolution_list.append(resolution)
                     
                     else :
-                        print " type %s"% structure.get_field_type("width")
+                        # raise error
+                        excep_message =  "unkown video type %s"% structure.get_field_type("width")
+                        raise LEXCEP.LucioException,excep_message  
+        
         for mimetype,res_list in webcam_device["video_formats"].iteritems():
             # loop on video on formats to stort it
             # data are sorted by width , in reverse order; i.e max res is the first in the list
@@ -314,7 +336,36 @@
         #    print "----- %s : %s"%(mimetype,res_list)
     gst_get_supported_video_formats = staticmethod(__gst_get_supported_video_formats)
 
-
+    def __gst_get_framerate(framerate_obj):
+        """ create a list of gst.Fraction framerates """ 
+        framerate = list()
+        if type(framerate_obj) == list :
+            framerate = framerate_obj
+        elif isinstance(framerate_obj, gst.FractionRange) :
+            # convert also to list of framerate
+            NB_FRAMERATE = 4
+            MAX_FRAMERATE = gst.Fraction(25,1)
+            
+            # limit max framerate 
+            if framerate_obj.high < MAX_FRAMERATE :
+                framerate_obj.high = MAX_FRAMERATE
+            
+            new_framerate = framerate_obj.high
+            for i in range(NB_FRAMERATE) :
+                framerate.append(new_framerate)
+                new_framerate = new_framerate/2
+            # at end of loop append the lowest framerate if not 0
+            if framerate_obj.low != gst.Fraction(0,1) :
+                framerate.append(framerate_obj.low)
+        else :
+            # raise error
+            excep_message = " unable to detect framerate : unknown type : %s for "%(type(framerate_obj),framerate_obj)
+            raise LEXCEP.LucioException,excep_message  
+        # transform framerate in not gst format
+        if framerate != None :
+            framerate_trans = [ (fraction.num,fraction.denom) for fraction in framerate]
+        return framerate_trans
+    gst_get_framerate = staticmethod(__gst_get_framerate)
 
 if __name__ == '__main__' :
     # TEST PURPOSE  : for webcam detection
@@ -322,11 +373,14 @@
     val = CamObj.detect_webcam()
     print " found %s webCam device "%val
 
-    if val >0 :
-        for device in CamObj.webcam_devices : 
-            for k,j in device.iteritems() : print "%s : %s"%(k,j)
-            print "----------------------------------------------------------------"
-
-
-
+    #if val >0 :
+    #    for device in CamObj.webcam_devices : 
+    #        for k,j in device.iteritems() : print "%s : %s"%(k,j)
+    #        print "----------------------------------------------------------------"
+    for i in range(val) :
+    #for enumerate(index,device) in CamObj.webcam_devices :
+        best = CamObj.get_gst_best_input(i)
+        print "Best webcam resolution found " 
+        print best
+        print "\n \n"
 
 
=== modified file 'lucioLib/luciole_controller.py'
--- lucioLib/luciole_controller.py	2009-12-14 06:15:44 +0000
+++ lucioLib/luciole_controller.py	2010-01-29 07:10:30 +0000
@@ -123,10 +123,6 @@
         project_dico_data = LP.project_dico() 
         for k,v in project_data.iteritems() :
             project_dico_data[k] = project_data[k]
-            #convert webcam_data as str values to be coherent with load of webcam data from a file
-            if k == 'webcam_data' : 
-                for w_k in project_dico_data[k].keys() :
-                    project_dico_data[k][w_k] = "%s"%project_dico_data[k][w_k]
         self.project = project_dico_data
 
         # 2. create project ( folder structure ,etc ...)
@@ -146,8 +142,17 @@
             # if a project is loaded close it
             print """ DEBUG : Close project Before """ 
             self.close()
-
-        self.project = self.project_ctrller.open(project_path)
+        try :
+            (is_valid,self.project) = self.project_ctrller.open(project_path)
+        except L_EXCEP.LucioException,err :
+            print err
+        
+        # webcam data are not valid
+        if is_valid == False :
+            msg = _(" Webcam data not valid in project. Please restart webcam detection")
+            LTK.Dialog.ErrorMessage(self.gui.window, msg)
+
+
 
         # 3. load project in application
         self.__load_project_in_app()
 
=== modified file 'lucioLib/luciole_project.py'
--- lucioLib/luciole_project.py	2009-04-24 13:42:04 +0000
+++ lucioLib/luciole_project.py	2010-01-29 07:10:30 +0000
@@ -4,7 +4,7 @@
 # vi:si:ai:et:sw=4:sts=4:ts=4
 #
 #
-# Copyright Nicolas Bertrand ([e-mail]), 2009
+# Copyright Nicolas Bertrand ([e-mail]), 2009,2010
 #
 # This file is part of Luciole.
 #
@@ -30,18 +30,49 @@
 import xml.etree.ElementTree as ET #python 2.5
 from xml.parsers.expat import ParserCreate, ExpatError
 
+
 import luciole_constants as LCONST
 import luciole_tools as LT
 import luciole_exceptions as L_EXCEP
 
 class project_dico(dict):
+    """ 
+    Luciole project dicitionary : contains all porject data as dictionary 
+    """
+    
+    #
+    # CONSTANTS
+    #
+
+    # mandatory tags for webcam description 
+    WEBCAM_DATA_TAGS = [ 'name',
+                        'device',
+                        'source_input',
+                        'height',
+                        'width',
+                        'framerate_list',
+                        'framerate_selected',
+                        ]
+    
+    # default values for webcam
+    WEBCAM_TAGS_DEFAULT_VALUES = {
+            'framerate_list' : [(5,1) ],
+            'framerate_selected' : (5,1)  ,
+            }
+                    
+   
     def __init__(self):
+        """ constructor : init a dict """
         super(project_dico,self).__init__()
 
 class project_controller(object) :
+    """ 
+    Class for handling luciole projects : creation, open, save
+    """
+   
     
     def __init__(self):
-        pass
+        """ Constructor"""
         # by default no project loaded
         self.__project_loaded = False
     
@@ -170,21 +201,44 @@
                 # loop on webcam data and save on data dictionary
                 webcam_data={}
                 for my_item in et_webcam_data.getchildren() :
-                    webcam_data[my_item.tag] = my_item.attrib.get("key")
-                # create acquisition object
-                p_project['webcam_data'] =webcam_data  
+                    # for framerate_selected and framerate_list tage : evaluate to convert in tuple and list
+                    # for others keep it as str
+                    if my_item.tag == 'framerate_selected' or my_item.tag == 'framerate_list' :
+                        webcam_data[my_item.tag] = eval(my_item.attrib.get("key"))
+                    else :
+                        webcam_data[my_item.tag] = my_item.attrib.get("key")
+
+                # check webcam data validity 
+                is_valid = True
+                missing_tags = [] 
+                for data in p_project.WEBCAM_DATA_TAGS :
+                    if not webcam_data.has_key(data) :
+                        is_valid = False
+                        missing_tags.append(data)
+
+                if is_valid == False :
+                    # not a valid project
+                    for missing_tag in missing_tags :
+                        if p_project.WEBCAM_TAGS_DEFAULT_VALUES.has_key(missing_tag) :
+                            webcam_data[missing_tag] = p_project.WEBCAM_TAGS_DEFAULT_VALUES[missing_tag]
+                            print missing_tag
+                        else :
+                            err = 'Invalid Project webcam data , tag %s is missing  '%missing_tag
+                            raise L_EXCEP.LucioException, err
+                
+                p_project['webcam_data'] = webcam_data
             else :
-                # nbd@grape : raise Error
-                print " Invalide webcam data found "
-                return None
-        
+                # raise Error
+                err =  "Invalid webcam data found "
+                raise L_EXCEP.LucioException, err
+
         p_project['rush_images'] = self.__scanImages("rushData") 
         p_project['capture_images'] = self.__scanImages("captureData") 
         p_project['chrono_images'] = self.__scanImages("chronoData") 
       
         p_project = self.__check_rush_images(p_project)
         
-        return p_project
+        return (is_valid,p_project)
 
 
     def __scanImages(self,p_type) :
 
=== modified file 'luciole.py'
--- luciole.py	2009-12-10 05:12:06 +0000
+++ luciole.py	2010-01-29 07:10:30 +0000
@@ -47,6 +47,8 @@
     logger = logging.getLogger("luciole")
     if is_verbose == True :
         logger.setLevel(logging.DEBUG)
+    else :
+        logger.setLevel(logging.INFO)
             
     # create console handler with a higher log level
     ch = logging.StreamHandler()