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

[NicoInattendu]

Bug fixes :
Bug #872053

=== modified file 'lucioLib/lcl_gst/lcl_gst_acq.py'
--- lucioLib/lcl_gst/lcl_gst_acq.py	2010-02-03 07:31:45 +0000
+++ lucioLib/lcl_gst/lcl_gst_acq.py	2011-10-10 23:30:28 +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.
 #
@@ -42,20 +42,31 @@
     """ 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 "
+    JPEG_CAPS_FILTER =  " video/x-raw-rgb, framerate=1/1, bpp=24, depth=24"
+    #JPEG_CAPS_FILTER =  " video/x-raw-yuv, framerate=5/1"
     
-    def __init__(self) :
+    def __init__(self, _cb_capture_done) :
         """
         Description of pipeline :
-        sink pad | jpegenc -->  fakesink | 
+        sink pad | videorate --> csp --> capsfilter -->  fakesink |
+        Jpeg conversion is done on demand, when a capture is requested,
+        on the caalback. Jpeg conversion is done only when necessary
+        from a pixbuf.
+         
         """
 
         super(PhotoSaveBin,self).__init__()
+        self._cb_capture_done = _cb_capture_done
+        self.capture_handler_id = 0
         ImageBinElems=[]
         
-        Myvideorate = LG.element_factory_make('videorate')                    #  rate transformation
+        Myvideorate = LG.element_factory_make('videorate','ImageRate')                    #  rate transformation
         ImageBinElems.append(Myvideorate)
-
+        
+        #  csp transformation
+        csp = LG.element_factory_make('ffmpegcolorspace','ImageCsp')
+        ImageBinElems.append(csp)                    
+        
         MyJpegFilter = LG.element_factory_make("capsfilter", "JpegFilter")
         # create caps string according, width, height and framerate
         caps = LG.Caps(self.JPEG_CAPS_FILTER)
@@ -64,18 +75,62 @@
         MyJpegFilter.set_property("caps", caps)
         ImageBinElems.append(MyJpegFilter)
 
-        MyJpegenc = LG.element_factory_make("jpegenc","MyJpegenc")                 # jpeg encoding
-        ImageBinElems.append(MyJpegenc)   
+        #MyJpegenc = LG.element_factory_make("jpegenc","MyJpegenc")                 # jpeg encoding
+        #ImageBinElems.append(MyJpegenc)   
         
-        photosink = LG.element_factory_make("fakesink","PhotoSink")
-        ImageBinElems.append(photosink)   
+        self.photosink = LG.element_factory_make("fakesink","PhotoSink")
+        self.photosink.set_property("signal-handoffs", 'true')
+        ImageBinElems.append(self.photosink)   
         
         for elem in ImageBinElems : self.add(elem)
         
-        LG.element_link_many(Myvideorate,MyJpegFilter,MyJpegenc,photosink)
+        LG.element_link_many(Myvideorate, csp, MyJpegFilter, self.photosink)
         
         self.add_pad(LG.GhostPad('sink', Myvideorate.get_pad('sink')))
 
+    def capture(self, filename =None ) :
+        """ capture a frame / data with handoff signals """
+
+        if self.capture_handler_id != 0 :
+            self.warning('Skipping capture request. Capture on progress')
+            return
+               
+        self.capture_handler_id = \
+                self.photosink.connect('handoff', self.process_data_cb, filename )
+        return
+
+    def process_data_cb(self, gbin ,data_buffer, pad, filename ) :
+        _bits_per_pixel = 8
+                
+        _caps = data_buffer.get_caps()
+        _structure = _caps[0]
+        _width = _structure["width"]
+        _height = _structure["height"]
+        # generate pixbuf
+        self.photosink.disconnect(self.capture_handler_id)
+        self.capture_handler_id = 0
+        
+        # save to file 
+        _file = open(filename,'w')
+        _file.write(data_buffer)
+        _file.close()
+
+        _pixbuf = gtk.gdk.pixbuf_new_from_data(
+            data_buffer.copy_on_write(),
+            gtk.gdk.COLORSPACE_RGB,
+            False,
+            _bits_per_pixel,
+            _width,
+            _height,
+            data_buffer.size / _height)
+        
+              
+        # save pixbuf to file
+        if filename != None :
+            _pixbuf.save(filename, "jpeg", {"quality":"100"})
+        
+        self.debug('Write Jpeg on %s'%(filename))         
+        self._cb_capture_done()    
 
 class InputImageBin(LG.Bin):
     """ Load image to mix with stream"""
@@ -592,8 +647,8 @@
         queueFile = LG.element_factory_make("queue","queueFile")              
         ElementList.append(queueFile)
         #fileSink = SaveCapturedImageBin(self.__CaptureImagePath)
-        fileSink = PhotoSaveBin()
-        ElementList.append(fileSink)
+        self.fileSink = PhotoSaveBin(self._cb_process_frame)
+        ElementList.append(self.fileSink)
         
         #
         # Display queue
@@ -617,7 +672,7 @@
         #link input
         LG.element_link_many(InputBin,MyTee)
         # link  tee File branch 
-        LG.element_link_many(MyTee,queueFile,fileSink)
+        LG.element_link_many(MyTee,queueFile, self.fileSink)
         #link tee display Branch
         LG.element_link_many(MyTee,queueDisplay)
         if (self.__mix == self.MIX) :
@@ -633,28 +688,19 @@
     
     def capture(self) :
         """ capture is requested : 
-            - get jpegnec src pad (output pad of jpege enc)
-            - and add a buffer probe with callback when frame is encoded
+            capture and JpegConversion are done on PhotoSaveBin
         """
-        # only one src pad with jpegenc
-        pad = self.pipe.get_by_name("MyJpegenc").src_pads().next()
-        # add the probe
-        self.grabprobe = pad.add_buffer_probe(self._cb_process_frame)
-    
-        
-    def _cb_process_frame(self, pad, buffer):
-        """ Callbak to inidicate that buffer is available from probe """
-        # remove the prove
-        pad.remove_buffer_probe(self.grabprobe)
-        
-        # save to file 
-        file = open(self.__CaptureImagePath,'w')
-        file.write(buffer)
-        file.close()
-        
-        # callback to indicate that job is done
-        # the execution here is not in the same thread as gui , so call capture_done with idle add
-        if self._cb_capture_done != None : gobject.idle_add(self._cb_capture_done) 
+
+        return self.fileSink.capture(self.__CaptureImagePath)
+       
+        
+    def _cb_process_frame(self):
+        """ Callback to inidicate capture and jpeg conversions are done"""
+      
+       
+        if self._cb_capture_done != None :
+		    gobject.idle_add(self._cb_capture_done) 
+		 
 
         return True