Remove trailing spaces.
[vlc.git] / modules / video_filter / opencv_wrapper.c
1 /*****************************************************************************
2  * opencv_wrapper.c : OpenCV wrapper video filter
3  *****************************************************************************
4  * Copyright (C) 2006 the VideoLAN team
5  *
6  * Authors: Dugal Harris <dugalh@protoclea.co.za>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
21  *****************************************************************************/
22
23 /*****************************************************************************
24  * Preamble
25  *****************************************************************************/
26 #include <stdlib.h>                                      /* malloc(), free() */
27 #include <string.h>
28
29 #include <cxcore.h>
30 #include <cv.h>
31 #include <highgui.h>
32
33 #include <vlc/vlc.h>
34 #include <vlc_vout.h>
35
36 #include <math.h>
37 #include <time.h>
38
39 #include "vlc_filter.h"
40 #include "filter_common.h"
41 #include <vlc_charset.h>
42 #include "vlc_image.h"
43 #include "vlc_input.h"
44 #include "vlc_playlist.h"
45
46
47 /*****************************************************************************
48  * Local prototypes
49  *****************************************************************************/
50 static int  Create    ( vlc_object_t * );
51 static void Destroy   ( vlc_object_t * );
52
53 static int  Init      ( vout_thread_t * );
54 static void End       ( vout_thread_t * );
55 static void Render    ( vout_thread_t *, picture_t * );
56
57 static int  SendEvents( vlc_object_t *, char const *,
58                         vlc_value_t, vlc_value_t, void * );
59 static void ReleaseImages( vout_thread_t *p_vout );
60 static void VlcPictureToIplImage( vout_thread_t *p_vout, picture_t *p_in );
61
62 /*****************************************************************************
63  * Module descriptor
64  *****************************************************************************/
65
66 static char *chroma_list[] = { "input", "I420", "RGB32"};
67 static char *chroma_list_text[] = { N_("Use input chroma unaltered"),
68   N_("I420 - first plane is greyscale"), N_("RGB32")};
69
70 static char *output_list[] = { "none", "input", "processed"};
71 static char *output_list_text[] = { N_("Don't display any video"),
72   N_("Display the input video"), N_("Display the processed video")};
73
74 static char *verbosity_list[] = { "error", "warning", "debug"};
75 static char *verbosity_list_text[] = { N_("Show only errors"),
76   N_("Show errors and warnings"), N_("Show everything including debug messages")};
77
78 vlc_module_begin();
79     set_description( _("OpenCV video filter wrapper") );
80     set_shortname( _("OpenCV" ));
81     set_category( CAT_VIDEO );
82     set_subcategory( SUBCAT_VIDEO_VFILTER );
83     set_capability( "video filter", 0 );
84     add_shortcut( "opencv_wrapper" );
85     set_callbacks( Create, Destroy );
86     add_float_with_range( "opencv-scale", 1.0, 0.1, 2.0, NULL,
87                           N_("Scale factor (0.1-2.0)"),
88                           N_("Ammount by which to scale the picture before sending it to the internal OpenCV filter"),
89                           VLC_FALSE );
90     add_string( "opencv-chroma", "input", NULL,
91                           N_("OpenCV filter chroma"),
92                           N_("Chroma to convert picture to before sending it to the internal OpenCV filter"), VLC_FALSE);
93         change_string_list( chroma_list, chroma_list_text, 0);
94     add_string( "opencv-output", "input", NULL,
95                           N_("Wrapper filter output"),
96                           N_("Determines what (if any) video is displayed by the wrapper filter"), VLC_FALSE);
97         change_string_list( output_list, output_list_text, 0);
98     add_string( "opencv-verbosity", "error", NULL,
99                           N_("Wrapper filter verbosity"),
100                           N_("Determines wrapper filter verbosity level"), VLC_FALSE);
101         change_string_list( verbosity_list, verbosity_list_text, 0);
102     add_string( "opencv-filter-name", "none", NULL,
103                           N_("OpenCV internal filter name"),
104                           N_("Name of internal OpenCV plugin filter to use"), VLC_FALSE);
105 vlc_module_end();
106
107
108 /*****************************************************************************
109  * wrapper_output_t: what video is output
110  *****************************************************************************/
111 enum wrapper_output_t
112 {
113    NONE,    //not working yet
114    VINPUT,
115    PROCESSED
116 };
117
118 /*****************************************************************************
119  * internal_chroma_t: what chroma is sent to the internal opencv filter
120  *****************************************************************************/
121 enum internal_chroma_t
122 {
123    CINPUT,
124    GREY,
125    RGB
126 };
127
128 /*****************************************************************************
129  * verbosity_t:
130  *****************************************************************************/
131 enum verbosity_t
132 {
133    VERB_ERROR,
134    VERB_WARN,
135    VERB_DEBUG
136 };
137
138 /*****************************************************************************
139  * vout_sys_t: opencv_wrapper video output method descriptor
140  *****************************************************************************
141  * This structure is part of the video output thread descriptor.
142  * It describes the opencv_wrapper specific properties of an output thread.
143  *****************************************************************************/
144 struct vout_sys_t
145 {
146     vout_thread_t *p_vout;
147
148     image_handler_t *p_image;
149
150     int i_cv_image_size;
151
152     picture_t *p_proc_image;
153     picture_t *p_to_be_freed;
154
155     float f_scale;
156
157     int i_wrapper_output;
158     int i_internal_chroma;
159     int i_verbosity;
160
161     IplImage *p_cv_image[VOUT_MAX_PLANES];
162
163     filter_t *p_opencv;
164     char* psz_inner_name;
165
166     picture_t hacked_pic;
167 };
168
169 /*****************************************************************************
170  * Control: control facility for the vout (forwards to child vout)
171  *****************************************************************************/
172 static int Control( vout_thread_t *p_vout, int i_query, va_list args )
173 {
174     return vout_vaControl( p_vout->p_sys->p_vout, i_query, args );
175 }
176
177 /*****************************************************************************
178  * Create: allocates opencv_wrapper video thread output method
179  *****************************************************************************
180  * This function allocates and initializes a opencv_wrapper vout method.
181  *****************************************************************************/
182 static int Create( vlc_object_t *p_this )
183 {
184     vout_thread_t *p_vout = (vout_thread_t *)p_this;
185     char *psz_chroma, *psz_output, *psz_verbosity;
186     int i = 0;
187
188     /* Allocate structure */
189     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
190     if( p_vout->p_sys == NULL )
191     {
192         msg_Err( p_vout, "out of memory" );
193         return VLC_ENOMEM;
194     }
195
196     /* Init structure */
197     p_vout->p_sys->p_image = image_HandlerCreate( p_vout );
198     for (i = 0; i < VOUT_MAX_PLANES; i++)
199         p_vout->p_sys->p_cv_image[i] = NULL;
200     p_vout->p_sys->p_proc_image = NULL;
201     p_vout->p_sys->p_to_be_freed = NULL;
202     p_vout->p_sys->i_cv_image_size = 0;
203
204     p_vout->pf_init = Init;
205     p_vout->pf_end = End;
206     p_vout->pf_manage = NULL;
207     p_vout->pf_render = Render;
208     p_vout->pf_display = NULL;
209     p_vout->pf_control = Control;
210
211     /* Retrieve and apply config */
212     if( !(psz_chroma = config_GetPsz( p_vout, "opencv-chroma" )) )
213     {
214         msg_Err( p_vout, "configuration variable %s empty, using 'grey'",
215                          "opencv-chroma" );
216         p_vout->p_sys->i_internal_chroma = GREY;
217     }
218     else
219     {
220         if( !strcmp( psz_chroma, "input" ) )
221             p_vout->p_sys->i_internal_chroma = CINPUT;
222         else if( !strcmp( psz_chroma, "I420" ) )
223             p_vout->p_sys->i_internal_chroma = GREY;
224         else if( !strcmp( psz_chroma, "RGB32" ) )
225             p_vout->p_sys->i_internal_chroma = RGB;
226         else
227         {
228             msg_Err( p_vout, "no valid opencv-chroma provided, using 'grey'" );
229             p_vout->p_sys->i_internal_chroma = GREY;
230         }
231     }
232     free( psz_chroma);
233
234     if( !(psz_output = config_GetPsz( p_vout, "opencv-output" )) )
235     {
236         msg_Err( p_vout, "configuration variable %s empty, using 'input'",
237                          "opencv-output" );
238         p_vout->p_sys->i_wrapper_output = VINPUT;
239     }
240     else
241     {
242         if( !strcmp( psz_output, "none" ) )
243             p_vout->p_sys->i_wrapper_output = NONE;
244         else if( !strcmp( psz_output, "input" ) )
245             p_vout->p_sys->i_wrapper_output = VINPUT;
246         else if( !strcmp( psz_output, "processed" ) )
247             p_vout->p_sys->i_wrapper_output = PROCESSED;
248         else
249         {
250             msg_Err( p_vout, "no valid opencv-output provided, using 'input'" );
251             p_vout->p_sys->i_wrapper_output = VINPUT;
252         }
253     }
254     free( psz_output);
255
256     if( !(psz_verbosity = config_GetPsz( p_vout, "opencv-verbosity" )) )
257     {
258         msg_Err( p_vout, "configuration variable %s empty, using 'input'",
259                          "opencv-verbosity" );
260         p_vout->p_sys->i_verbosity = VERB_ERROR;
261     }
262     else
263     {
264         if( !strcmp( psz_verbosity, "error" ) )
265             p_vout->p_sys->i_verbosity = VERB_ERROR;
266         else if( !strcmp( psz_verbosity, "warning" ) )
267             p_vout->p_sys->i_verbosity = VERB_WARN;
268         else if( !strcmp( psz_verbosity, "debug" ) )
269             p_vout->p_sys->i_verbosity = VERB_DEBUG;
270         else
271         {
272             msg_Err( p_vout, "no valid opencv-verbosity provided, using 'error'" );
273             p_vout->p_sys->i_verbosity = VERB_ERROR;
274         }
275     }
276     free( psz_verbosity);
277
278     p_vout->p_sys->psz_inner_name = config_GetPsz( p_vout, "opencv-filter-name" );
279
280     p_vout->p_sys->f_scale =
281         config_GetFloat( p_vout, "opencv-scale" );
282
283     if (p_vout->p_sys->i_verbosity > VERB_WARN)
284         msg_Info(p_vout, "Configuration: opencv-scale: %f, opencv-chroma: %d, "
285             "opencv-output: %d, opencv-verbosity %d, opencv-filter %s",
286             p_vout->p_sys->f_scale,
287             p_vout->p_sys->i_internal_chroma,
288             p_vout->p_sys->i_wrapper_output,
289             p_vout->p_sys->i_verbosity,
290             p_vout->p_sys->psz_inner_name);
291
292     return VLC_SUCCESS;
293 }
294
295 /*****************************************************************************
296  * Init: initialize opencv_wrapper video thread output method
297  *****************************************************************************/
298 static int Init( vout_thread_t *p_vout )
299 {
300     int i_index;
301     picture_t *p_pic;
302     video_format_t fmt = {0};
303     vout_sys_t *p_sys = p_vout->p_sys;
304     I_OUTPUTPICTURES = 0;
305
306     /* Initialize the output video format */
307     p_vout->output.i_chroma = p_vout->render.i_chroma;
308     p_vout->output.i_width  = p_vout->render.i_width;
309     p_vout->output.i_height = p_vout->render.i_height;
310     p_vout->output.i_aspect = p_vout->render.i_aspect;
311     p_vout->fmt_out = p_vout->fmt_in;           //set to input video format
312
313     fmt = p_vout->fmt_out;
314     if (p_sys->i_wrapper_output == PROCESSED)   //set to processed video format
315     {
316         fmt.i_width = fmt.i_width * p_sys->f_scale;
317         fmt.i_height = fmt.i_height * p_sys->f_scale;
318         fmt.i_visible_width = fmt.i_visible_width * p_sys->f_scale;
319         fmt.i_visible_height = fmt.i_visible_height * p_sys->f_scale;
320         fmt.i_x_offset = fmt.i_x_offset * p_sys->f_scale;
321         fmt.i_y_offset = fmt.i_y_offset * p_sys->f_scale;
322
323         if (p_sys->i_internal_chroma == GREY)
324             fmt.i_chroma = VLC_FOURCC('I','4','2','0');
325         else if (p_sys->i_internal_chroma == RGB)
326             fmt.i_chroma = VLC_FOURCC('R','V','3','2');
327     }
328
329     /* Load the internal opencv filter */
330     /* We don't need to set up video formats for this filter as it not actually using a picture_t */
331     p_sys->p_opencv = vlc_object_create( p_vout, sizeof(filter_t) );
332     vlc_object_attach( p_sys->p_opencv, p_vout );
333
334     if (p_vout->p_sys->psz_inner_name)
335         p_sys->p_opencv->p_module =
336             module_Need( p_sys->p_opencv, p_sys->psz_inner_name, 0, 0 );
337
338     if( !p_sys->p_opencv->p_module )
339     {
340         msg_Err( p_vout, "can't open internal opencv filter: %s", p_vout->p_sys->psz_inner_name );
341         p_vout->p_sys->psz_inner_name = NULL;
342         vlc_object_detach( p_sys->p_opencv );
343         vlc_object_destroy( p_sys->p_opencv );
344         p_sys->p_opencv = NULL;
345     }
346
347     /* Try to open the real video output */
348     if (p_sys->i_verbosity > VERB_WARN)
349         msg_Dbg( p_vout, "spawning the real video output" );
350
351     p_vout->p_sys->p_vout = vout_Create( p_vout, &fmt );
352
353     /* Everything failed */
354     if( p_vout->p_sys->p_vout == NULL )
355     {
356         msg_Err( p_vout, "can't open vout, aborting" );
357         return VLC_EGENERIC;
358     }
359
360     ALLOCATE_DIRECTBUFFERS( VOUT_MAX_PICTURES );
361
362     ADD_CALLBACKS( p_vout->p_sys->p_vout, SendEvents );
363
364     ADD_PARENT_CALLBACKS( SendEventsToChild );
365
366     return VLC_SUCCESS;
367 }
368
369 /*****************************************************************************
370  * End: terminate opencv_wrapper video thread output method
371  *****************************************************************************/
372 static void End( vout_thread_t *p_vout )
373 {
374     int i_index;
375
376     /* Free the fake output buffers we allocated */
377     for( i_index = I_OUTPUTPICTURES ; i_index ; )
378     {
379         i_index--;
380         free( PP_OUTPUTPICTURE[ i_index ]->p_data_orig );
381     }
382
383     if ( p_vout->p_sys->p_opencv )
384     {
385         //release the internal opencv filter
386         if( p_vout->p_sys->p_opencv->p_module )
387             module_Unneed( p_vout->p_sys->p_opencv, p_vout->p_sys->p_opencv->p_module );
388         vlc_object_detach( p_vout->p_sys->p_opencv );
389         vlc_object_destroy( p_vout->p_sys->p_opencv );
390         p_vout->p_sys->p_opencv = NULL;
391     }
392
393 }
394
395 /*****************************************************************************
396  * Destroy: destroy opencv_wrapper video thread output method
397  *****************************************************************************
398  * Terminate an output method created by opencv_wrapperCreateOutputMethod
399  *****************************************************************************/
400 static void Destroy( vlc_object_t *p_this )
401 {
402     vout_thread_t *p_vout = (vout_thread_t *)p_this;
403
404     if( p_vout->p_sys->p_vout )
405     {
406         DEL_CALLBACKS( p_vout->p_sys->p_vout, SendEvents );
407         vlc_object_detach( p_vout->p_sys->p_vout );
408         vout_Destroy( p_vout->p_sys->p_vout );
409     }
410
411     DEL_PARENT_CALLBACKS( SendEventsToChild );
412
413     ReleaseImages(p_vout);
414
415     if( p_vout->p_sys->p_image )
416         image_HandlerDelete( p_vout->p_sys->p_image );
417
418     free( p_vout->p_sys );
419 }
420
421 /*****************************************************************************
422  * ReleaseImages: Release OpenCV images in vout_sys_t.
423  *****************************************************************************/
424 static void ReleaseImages(vout_thread_t *p_vout)
425 {
426     int i = 0;
427     if (p_vout->p_sys->p_cv_image)
428     {
429         for (i = 0; i < VOUT_MAX_PLANES; i++)
430         {
431             if (p_vout->p_sys->p_cv_image[i])
432                 cvReleaseImageHeader(&(p_vout->p_sys->p_cv_image[i]));
433             p_vout->p_sys->p_cv_image[i] = NULL;
434         }
435     }
436     p_vout->p_sys->i_cv_image_size = 0;
437
438     /* Release temp picture_t if it exists */
439     if (p_vout->p_sys->p_to_be_freed)
440     {
441         p_vout->p_sys->p_to_be_freed->pf_release( p_vout->p_sys->p_to_be_freed );
442         p_vout->p_sys->p_to_be_freed = NULL;
443     }
444     if (p_vout->p_sys->i_verbosity > VERB_WARN)
445         msg_Dbg( p_vout, "images released" );
446 }
447
448 /*****************************************************************************
449  * VlcPictureToIplImage: Convert picture_t to IplImage
450  *****************************************************************************
451  * Converts given picture_t into IplImage(s) according to module config.
452  * IplImage(s) are stored in vout_sys_t.
453  *****************************************************************************/
454 static void VlcPictureToIplImage( vout_thread_t *p_vout, picture_t *p_in )
455 {
456     int planes = p_in->i_planes;    //num input video planes
457     // input video size
458     CvSize sz = cvSize(abs(p_in->format.i_width), abs(p_in->format.i_height));
459     video_format_t fmt_out = {0};
460     clock_t start, finish;  //performance measures
461     double  duration;
462     int i = 0;
463     vout_sys_t* p_sys = p_vout->p_sys;
464
465     start = clock();
466
467     //do scale / color conversion according to p_sys config
468     if ((p_sys->f_scale != 1) || (p_sys->i_internal_chroma != CINPUT))
469     {
470         fmt_out = p_in->format;
471
472         //calc the scaled video size
473         fmt_out.i_width = p_in->format.i_width * p_sys->f_scale;
474         fmt_out.i_height = p_in->format.i_height * p_sys->f_scale;
475
476         if (p_sys->i_internal_chroma == RGB)
477         {
478             //rgb2 gives 3 separate planes, this gives 1 interleaved plane
479             //rv24 gives is about 20% faster but gives r&b the wrong way round
480             //and I cant think of an easy way to fix this
481             fmt_out.i_chroma = VLC_FOURCC('R','V','3','2');
482         }
483         else if (p_sys->i_internal_chroma == GREY)
484         {
485             //take the I (gray) plane (video seems to commonly be in this fmt so usually the
486             //conversion does nothing)
487             fmt_out.i_chroma = VLC_FOURCC('I','4','2','0');
488         }
489
490         //convert from the input image
491         p_sys->p_proc_image = image_Convert( p_sys->p_image, p_in,
492                                      &(p_in->format), &fmt_out );
493
494         if (!p_sys->p_proc_image)
495         {
496             msg_Err(p_vout, "can't convert (unsupported formats?), aborting...");
497             return;
498         }
499
500         p_sys->p_to_be_freed = p_sys->p_proc_image;    //remember this so we can free it later
501
502     }
503     else    //((p_sys->f_scale != 1) || (p_sys->i_internal_chroma != CINPUT))
504     {
505         //use the input image without conversion
506         p_sys->p_proc_image = p_in;
507     }
508
509     //Convert to the IplImage array that is to be processed.
510     //If there are multiple planes in p_sys->p_proc_image, then 1 IplImage
511     //is created for each plane.
512     planes = p_sys->p_proc_image->i_planes;
513     p_sys->i_cv_image_size = planes;
514     for ( i = 0; i < planes; i++ )
515     {
516         sz = cvSize(abs(p_sys->p_proc_image->p[i].i_visible_pitch /
517             p_sys->p_proc_image->p[i].i_pixel_pitch),
518             abs(p_sys->p_proc_image->p[i].i_visible_lines));
519
520         p_sys->p_cv_image[i] = cvCreateImageHeader(sz, IPL_DEPTH_8U,
521             p_sys->p_proc_image->p[i].i_pixel_pitch);
522
523         cvSetData( p_sys->p_cv_image[i],
524             (char*)(p_sys->p_proc_image->p[i].p_pixels), p_sys->p_proc_image->p[i].i_pitch );
525     }
526
527     //Hack the above opencv image array into a picture_t so that it can be sent to
528     //another video filter
529     p_sys->hacked_pic.p_data_orig = p_sys->p_cv_image;
530     p_sys->hacked_pic.i_planes = planes;
531     p_sys->hacked_pic.format.i_chroma = fmt_out.i_chroma;
532
533     //calculate duration of conversion
534     finish = clock();
535     duration = (double)(finish - start) / CLOCKS_PER_SEC;
536     if (p_sys->i_verbosity > VERB_WARN)
537         msg_Dbg( p_vout, "VlcPictureToIplImageRgb took %2.4f seconds\n", duration );
538 }
539
540 /*****************************************************************************
541  * Render: displays previously rendered output
542  *****************************************************************************
543  * This function send the currently rendered image to the internal opencv
544  * filter for processing.
545  *****************************************************************************/
546 static void Render( vout_thread_t *p_vout, picture_t *p_pic )
547 {
548     picture_t *p_outpic = NULL;
549     clock_t start, finish;
550     double  duration;
551
552     while( ( p_outpic = vout_CreatePicture( p_vout->p_sys->p_vout, 0, 0, 0 ) )
553               == NULL )
554     {
555         if( p_vout->b_die || p_vout->b_error )
556         {   return; }
557         msleep( VOUT_OUTMEM_SLEEP );
558     }
559
560     vout_LinkPicture( p_vout->p_sys->p_vout, p_outpic );
561
562     start = clock();
563
564     if (p_vout->p_sys->i_wrapper_output == VINPUT)  //output = input video
565     {
566         //This copy is a bit unfortunate but image_Convert can't write into an existing image so it is better to copy the
567         //(say) 16bit YUV image here than a 32bit RGB image somehwere else.
568         //It is also not that expensive in time.
569         vout_CopyPicture( p_vout, p_outpic, p_pic );
570         VlcPictureToIplImage( p_vout, p_pic);
571         //pass the image to the internal opencv filter for processing
572         if ((p_vout->p_sys->p_opencv) && (p_vout->p_sys->p_opencv->p_module))
573             p_vout->p_sys->p_opencv->pf_video_filter( p_vout->p_sys->p_opencv, &(p_vout->p_sys->hacked_pic));
574     }
575     else    //output = processed video (NONE option not working yet)
576     {
577         VlcPictureToIplImage( p_vout, p_pic);
578         //pass the image to the internal opencv filter for processing
579         if ((p_vout->p_sys->p_opencv) && (p_vout->p_sys->p_opencv->p_module))
580             p_vout->p_sys->p_opencv->pf_video_filter( p_vout->p_sys->p_opencv, &(p_vout->p_sys->hacked_pic));
581         //copy the processed image into the output image
582         if ((p_vout->p_sys->p_proc_image) && (p_vout->p_sys->p_proc_image->p_data))
583             vout_CopyPicture( p_vout, p_outpic, p_vout->p_sys->p_proc_image );
584     }
585
586     //calculate duration
587     finish = clock();
588     duration = (double)(finish - start) / CLOCKS_PER_SEC;
589     if (p_vout->p_sys->i_verbosity > VERB_WARN)
590         msg_Dbg( p_vout, "Render took %2.4f seconds\n", duration );
591
592     ReleaseImages(p_vout);
593     vout_DatePicture( p_vout->p_sys->p_vout, p_outpic, p_pic->date );
594         
595     vout_UnlinkPicture( p_vout->p_sys->p_vout, p_outpic );
596     vout_DisplayPicture( p_vout->p_sys->p_vout, p_outpic );
597 }
598
599 /*****************************************************************************
600  * SendEvents: forward mouse and keyboard events to the parent p_vout
601  *****************************************************************************/
602 static int SendEvents( vlc_object_t *p_this, char const *psz_var,
603                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
604 {
605     var_Set( (vlc_object_t *)p_data, psz_var, newval );
606
607     return VLC_SUCCESS;
608 }
609
610 /*****************************************************************************
611  * SendEventsToChild: forward events to the child/children vout
612  *****************************************************************************/
613 static int SendEventsToChild( vlc_object_t *p_this, char const *psz_var,
614                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
615 {
616     vout_thread_t *p_vout = (vout_thread_t *)p_this;
617     var_Set( p_vout->p_sys->p_vout, psz_var, newval );
618     return VLC_SUCCESS;
619 }