filter_chain: add filter_chain_ForEach() helper
[vlc.git] / src / misc / filter_chain.c
1 /*****************************************************************************
2  * filter_chain.c : Handle chains of filter_t objects.
3  *****************************************************************************
4  * Copyright (C) 2008 VLC authors and VideoLAN
5  * Copyright (C) 2008-2014 RĂ©mi Denis-Courmont
6  *
7  * Author: Antoine Cellerier <dionoea at videolan dot org>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 #include <vlc_filter.h>
29 #include <vlc_modules.h>
30 #include <vlc_spu.h>
31 #include <libvlc.h>
32 #include <assert.h>
33
34 typedef struct
35 {
36     int (*pf_init)( filter_t *, void *p_data ); /* Callback called once filter allocation has succeeded to initialize the filter's buffer allocation callbacks. This function is responsible for setting p_owner if needed. */
37     void (* pf_clean)( filter_t * ); /* Callback called on filter removal from chain to clean up buffer allocation callbacks data (ie p_owner) */
38     void *p_data; /* Data for pf_buffer_allocation_init */
39
40 } filter_chain_allocator_t;
41
42 typedef struct chained_filter_t
43 {
44     /* Public part of the filter structure */
45     filter_t filter;
46     /* Private filter chain data (shhhh!) */
47     struct chained_filter_t *prev, *next;
48     vlc_mouse_t *mouse;
49     picture_t *pending;
50 } chained_filter_t;
51
52 /* Only use this with filter objects from _this_ C module */
53 static inline chained_filter_t *chained (filter_t *filter)
54 {
55     return (chained_filter_t *)filter;
56 }
57
58 static int  AllocatorInit( const filter_chain_allocator_t *,
59                            chained_filter_t * );
60 static void AllocatorClean( const filter_chain_allocator_t *,
61                             chained_filter_t * );
62
63 static bool IsInternalVideoAllocator( chained_filter_t * );
64
65 static int  InternalVideoInit( filter_t *, void * );
66
67 static const filter_chain_allocator_t internal_video_allocator = {
68     .pf_init = InternalVideoInit,
69     .pf_clean = NULL,
70     .p_data = NULL,
71 };
72
73 /* */
74 struct filter_chain_t
75 {
76     vlc_object_t *p_this; /**< Owner object */
77     filter_chain_allocator_t allocator; /**< Owner allocation callbacks */
78
79     chained_filter_t *first, *last; /**< List of filters */
80
81     es_format_t fmt_in; /**< Chain input format (constant) */
82     es_format_t fmt_out; /**< Chain current output format */
83     unsigned length; /**< Number of filters */
84     bool b_allow_fmt_out_change; /**< Can the output format be changed? */
85     char psz_capability[1]; /**< Module capability for all chained filters */
86 };
87
88 /**
89  * Local prototypes
90  */
91 static filter_t *filter_chain_AppendFilterInternal( filter_chain_t *,
92                                                     const char *, config_chain_t *,
93                                                     const es_format_t *, const es_format_t * );
94
95 static int filter_chain_DeleteFilterInternal( filter_chain_t *, filter_t * );
96
97 static int UpdateBufferFunctions( filter_chain_t * );
98
99 static void FilterDeletePictures( filter_t *, picture_t * );
100
101 #undef filter_chain_New
102 /**
103  * Filter chain initialisation
104  */
105 filter_chain_t *filter_chain_New( vlc_object_t *p_this,
106                                   const char *psz_capability,
107                                   bool b_allow_fmt_out_change,
108                                   int  (*pf_buffer_allocation_init)( filter_t *, void * ),
109                                   void (*pf_buffer_allocation_clean)( filter_t * ),
110                                   void *p_buffer_allocation_data )
111 {
112     assert( p_this );
113     assert( psz_capability );
114
115     size_t size = sizeof(filter_chain_t) + strlen(psz_capability);
116     filter_chain_t *p_chain = malloc( size );
117     if( !p_chain )
118         return NULL;
119
120     p_chain->p_this = p_this;
121     p_chain->last = p_chain->first = NULL;
122     p_chain->length = 0;
123     strcpy( p_chain->psz_capability, psz_capability );
124
125     es_format_Init( &p_chain->fmt_in, UNKNOWN_ES, 0 );
126     es_format_Init( &p_chain->fmt_out, UNKNOWN_ES, 0 );
127     p_chain->b_allow_fmt_out_change = b_allow_fmt_out_change;
128
129     p_chain->allocator.pf_init = pf_buffer_allocation_init;
130     p_chain->allocator.pf_clean = pf_buffer_allocation_clean;
131     p_chain->allocator.p_data = p_buffer_allocation_data;
132
133     return p_chain;
134 }
135
136 /**
137  * Filter chain destruction
138  */
139 void filter_chain_Delete( filter_chain_t *p_chain )
140 {
141     filter_chain_Reset( p_chain, NULL, NULL );
142
143     es_format_Clean( &p_chain->fmt_in );
144     es_format_Clean( &p_chain->fmt_out );
145
146     free( p_chain );
147 }
148 /**
149  * Filter chain reinitialisation
150  */
151 void filter_chain_Reset( filter_chain_t *p_chain, const es_format_t *p_fmt_in,
152                          const es_format_t *p_fmt_out )
153 {
154     while( p_chain->first != NULL )
155         filter_chain_DeleteFilterInternal( p_chain, &p_chain->first->filter );
156
157     if( p_fmt_in )
158     {
159         es_format_Clean( &p_chain->fmt_in );
160         es_format_Copy( &p_chain->fmt_in, p_fmt_in );
161     }
162     if( p_fmt_out )
163     {
164         es_format_Clean( &p_chain->fmt_out );
165         es_format_Copy( &p_chain->fmt_out, p_fmt_out );
166     }
167 }
168
169 filter_t *filter_chain_AppendFilter( filter_chain_t *p_chain,
170                                      const char *psz_name,
171                                      config_chain_t *p_cfg,
172                                      const es_format_t *p_fmt_in,
173                                      const es_format_t *p_fmt_out )
174 {
175     filter_t *p_filter = filter_chain_AppendFilterInternal( p_chain, psz_name,
176                                                             p_cfg, p_fmt_in,
177                                                             p_fmt_out );
178     if( UpdateBufferFunctions( p_chain ) < 0 )
179         msg_Err( p_filter, "Woah! This doesn't look good." );
180     return p_filter;
181 }
182
183 int filter_chain_AppendFromString( filter_chain_t *chain, const char *str )
184 {
185     char *buf = NULL;
186     int ret = 0;
187
188     while( str != NULL && str[0] != '\0' )
189     {
190         config_chain_t *cfg;
191         char *name;
192
193         char *next = config_ChainCreate( &name, &cfg, str );
194
195         str = next;
196         free( buf );
197         buf = next;
198
199         filter_t *filter = filter_chain_AppendFilterInternal( chain, name, cfg,
200                                                               NULL, NULL );
201         if( filter == NULL )
202         {
203             msg_Err( chain->p_this, "Failed while trying to append '%s' "
204                      "to filter chain", name );
205             free( name );
206             free( cfg );
207             goto error;
208         }
209
210         free( name );
211         ret++;
212     }
213
214     if( UpdateBufferFunctions( chain ) )
215         assert( 0 ); /* should never happen, vf2 alloc cannot fail */
216     free( buf );
217     return ret;
218
219 error:
220     while( ret > 0 ) /* Unwind */
221     {
222         filter_chain_DeleteFilterInternal( chain, &chain->last->filter );
223         ret--;
224     }
225     free( buf );
226     return -1;
227 }
228
229 int filter_chain_DeleteFilter( filter_chain_t *p_chain, filter_t *p_filter )
230 {
231     const int i_ret = filter_chain_DeleteFilterInternal( p_chain, p_filter );
232     if( i_ret < 0 )
233         return i_ret;
234
235     /* FIXME That one seems bad if a error is returned */
236     return UpdateBufferFunctions( p_chain );
237 }
238
239 int filter_chain_ForEach( filter_chain_t *chain,
240                           int (*cb)( filter_t *, void * ), void *opaque )
241 {
242     for( chained_filter_t *f = chain->first; f != NULL; f = f->next )
243     {
244         int ret = cb( &f->filter, opaque );
245         if( ret )
246             return ret;
247     }
248     return VLC_SUCCESS;
249 }
250
251 int filter_chain_GetLength( filter_chain_t *p_chain )
252 {
253     return p_chain->length;
254 }
255
256 const es_format_t *filter_chain_GetFmtOut( filter_chain_t *p_chain )
257 {
258
259     if( p_chain->b_allow_fmt_out_change )
260         return &p_chain->fmt_out;
261
262     if( p_chain->last != NULL )
263         return &p_chain->last->filter.fmt_out;
264
265     /* Unless filter_chain_Reset has been called we are doomed */
266     return &p_chain->fmt_out;
267 }
268
269 static picture_t *FilterChainVideoFilter( chained_filter_t *f, picture_t *p_pic )
270 {
271     for( ; f != NULL; f = f->next )
272     {
273         filter_t *p_filter = &f->filter;
274         p_pic = p_filter->pf_video_filter( p_filter, p_pic );
275         if( !p_pic )
276             break;
277         if( f->pending )
278         {
279             msg_Warn( p_filter, "dropping pictures" );
280             FilterDeletePictures( p_filter, f->pending );
281         }
282         f->pending = p_pic->p_next;
283         p_pic->p_next = NULL;
284     }
285     return p_pic;
286 }
287
288 picture_t *filter_chain_VideoFilter( filter_chain_t *p_chain, picture_t *p_pic )
289 {
290     if( p_pic )
291     {
292         p_pic = FilterChainVideoFilter( p_chain->first, p_pic );
293         if( p_pic )
294             return p_pic;
295     }
296     for( chained_filter_t *b = p_chain->last; b != NULL; b = b->prev )
297     {
298         p_pic = b->pending;
299         if( !p_pic )
300             continue;
301         b->pending = p_pic->p_next;
302         p_pic->p_next = NULL;
303
304         p_pic = FilterChainVideoFilter( b->next, p_pic );
305         if( p_pic )
306             return p_pic;
307     }
308     return NULL;
309 }
310
311 void filter_chain_VideoFlush( filter_chain_t *p_chain )
312 {
313     for( chained_filter_t *f = p_chain->first; f != NULL; f = f->next )
314     {
315         filter_t *p_filter = &f->filter;
316
317         FilterDeletePictures( p_filter, f->pending );
318         f->pending = NULL;
319
320         filter_FlushPictures( p_filter );
321     }
322 }
323
324
325 block_t *filter_chain_AudioFilter( filter_chain_t *p_chain, block_t *p_block )
326 {
327     for( chained_filter_t *f = p_chain->first; f != NULL; f = f->next )
328     {
329         filter_t *p_filter = &f->filter;
330
331         p_block = p_filter->pf_audio_filter( p_filter, p_block );
332         if( !p_block )
333             break;
334     }
335     return p_block;
336 }
337
338 void filter_chain_SubSource( filter_chain_t *p_chain,
339                              mtime_t display_date )
340 {
341     for( chained_filter_t *f = p_chain->first; f != NULL; f = f->next )
342     {
343         filter_t *p_filter = &f->filter;
344         subpicture_t *p_subpic = p_filter->pf_sub_source( p_filter, display_date );
345         /* XXX I find that spu_t cast ugly */
346         if( p_subpic )
347             spu_PutSubpicture( (spu_t*)p_chain->p_this, p_subpic );
348     }
349 }
350
351 subpicture_t *filter_chain_SubFilter( filter_chain_t *p_chain, subpicture_t *p_subpic )
352 {
353     for( chained_filter_t *f = p_chain->first; f != NULL; f = f->next )
354     {
355         filter_t *p_filter = &f->filter;
356
357         p_subpic = p_filter->pf_sub_filter( p_filter, p_subpic );
358
359         if( !p_subpic )
360             break;
361     }
362     return p_subpic;
363 }
364
365 int filter_chain_MouseFilter( filter_chain_t *p_chain, vlc_mouse_t *p_dst, const vlc_mouse_t *p_src )
366 {
367     vlc_mouse_t current = *p_src;
368
369     for( chained_filter_t *f = p_chain->last; f != NULL; f = f->prev )
370     {
371         filter_t *p_filter = &f->filter;
372         vlc_mouse_t *p_mouse = f->mouse;
373
374         if( p_filter->pf_video_mouse && p_mouse )
375         {
376             vlc_mouse_t old = *p_mouse;
377             vlc_mouse_t filtered;
378
379             *p_mouse = current;
380             if( p_filter->pf_video_mouse( p_filter, &filtered, &old, &current ) )
381                 return VLC_EGENERIC;
382             current = filtered;
383         }
384     }
385
386     *p_dst = current;
387     return VLC_SUCCESS;
388 }
389
390 int filter_chain_MouseEvent( filter_chain_t *p_chain,
391                              const vlc_mouse_t *p_mouse,
392                              const video_format_t *p_fmt )
393 {
394     for( chained_filter_t *f = p_chain->first; f != NULL; f = f->next )
395     {
396         filter_t *p_filter = &f->filter;
397
398         if( p_filter->pf_sub_mouse )
399         {
400             vlc_mouse_t old = *f->mouse;
401             *f->mouse = *p_mouse;
402             if( p_filter->pf_sub_mouse( p_filter, &old, p_mouse, p_fmt ) )
403                 return VLC_EGENERIC;
404         }
405     }
406
407     return VLC_SUCCESS;
408 }
409
410 /* Helpers */
411 static filter_t *filter_chain_AppendFilterInternal( filter_chain_t *p_chain,
412                                                     const char *psz_name,
413                                                     config_chain_t *p_cfg,
414                                                     const es_format_t *p_fmt_in,
415                                                     const es_format_t *p_fmt_out )
416 {
417     chained_filter_t *p_chained =
418         vlc_custom_create( p_chain->p_this, sizeof(*p_chained), "filter" );
419     filter_t *p_filter = &p_chained->filter;
420     if( !p_filter )
421         return NULL;
422
423     if( !p_fmt_in )
424     {
425         if( p_chain->last != NULL )
426             p_fmt_in = &p_chain->last->filter.fmt_out;
427         else
428             p_fmt_in = &p_chain->fmt_in;
429     }
430
431     if( !p_fmt_out )
432     {
433         p_fmt_out = &p_chain->fmt_out;
434     }
435
436     es_format_Copy( &p_filter->fmt_in, p_fmt_in );
437     es_format_Copy( &p_filter->fmt_out, p_fmt_out );
438     p_filter->p_cfg = p_cfg;
439     p_filter->b_allow_fmt_out_change = p_chain->b_allow_fmt_out_change;
440
441     p_filter->p_module = module_need( p_filter, p_chain->psz_capability,
442                                       psz_name, psz_name != NULL );
443
444     if( !p_filter->p_module )
445         goto error;
446
447     if( p_filter->b_allow_fmt_out_change )
448     {
449         es_format_Clean( &p_chain->fmt_out );
450         es_format_Copy( &p_chain->fmt_out, &p_filter->fmt_out );
451     }
452
453     if( AllocatorInit( &p_chain->allocator, p_chained ) )
454         goto error;
455
456     if( p_chain->last == NULL )
457     {
458         assert( p_chain->first == NULL );
459         p_chain->first = p_chained;
460     }
461     else
462         p_chain->last->next = p_chained;
463     p_chained->prev = p_chain->last;
464     p_chain->last = p_chained;
465     p_chained->next = NULL;
466     p_chain->length++;
467
468     vlc_mouse_t *p_mouse = malloc( sizeof(*p_mouse) );
469     if( p_mouse )
470         vlc_mouse_Init( p_mouse );
471     p_chained->mouse = p_mouse;
472     p_chained->pending = NULL;
473
474     msg_Dbg( p_chain->p_this, "Filter '%s' (%p) appended to chain",
475              psz_name ? psz_name : module_get_name(p_filter->p_module, false),
476              p_filter );
477
478     return p_filter;
479
480 error:
481     if( psz_name )
482         msg_Err( p_chain->p_this, "Failed to create %s '%s'",
483                  p_chain->psz_capability, psz_name );
484     else
485         msg_Err( p_chain->p_this, "Failed to create %s",
486                  p_chain->psz_capability );
487     if( p_filter->p_module )
488         module_unneed( p_filter, p_filter->p_module );
489     es_format_Clean( &p_filter->fmt_in );
490     es_format_Clean( &p_filter->fmt_out );
491     vlc_object_release( p_filter );
492     return NULL;
493 }
494
495 static int filter_chain_DeleteFilterInternal( filter_chain_t *p_chain,
496                                               filter_t *p_filter )
497 {
498     chained_filter_t *p_chained = chained( p_filter );
499
500     /* Remove it from the chain */
501     if( p_chained->prev != NULL )
502         p_chained->prev->next = p_chained->next;
503     else
504     {
505         assert( p_chained == p_chain->first );
506         p_chain->first = p_chained->next;
507     }
508
509     if( p_chained->next != NULL )
510         p_chained->next->prev = p_chained->prev;
511     else
512     {
513         assert( p_chained == p_chain->last );
514         p_chain->last = p_chained->prev;
515     }
516     p_chain->length--;
517
518     msg_Dbg( p_chain->p_this, "Filter %p removed from chain", p_filter );
519
520     FilterDeletePictures( &p_chained->filter, p_chained->pending );
521
522     /* Destroy the filter object */
523     if( IsInternalVideoAllocator( p_chained ) )
524         AllocatorClean( &internal_video_allocator, p_chained );
525     else
526         AllocatorClean( &p_chain->allocator, p_chained );
527
528     if( p_filter->p_module )
529         module_unneed( p_filter, p_filter->p_module );
530     free( p_chained->mouse );
531     vlc_object_release( p_filter );
532
533
534     /* FIXME: check fmt_in/fmt_out consitency */
535     return VLC_SUCCESS;
536 }
537
538 static void FilterDeletePictures( filter_t *filter, picture_t *picture )
539 {
540     while( picture )
541     {
542         picture_t *next = picture->p_next;
543         filter_DeletePicture( filter, picture );
544         picture = next;
545     }
546 }
547
548 /**
549  * Internal chain buffer handling
550  */
551
552 static int UpdateVideoBufferFunctions( filter_chain_t *p_chain )
553 {
554     /**
555      * Last filter uses the filter chain's parent buffer allocation
556      * functions. All the other filters use internal functions.
557      * This makes it possible to have format changes between each
558      * filter without having to worry about the parent's picture
559      * heap format.
560      */
561     /* FIXME: we should only update the last and penultimate filters */
562     chained_filter_t *f;
563
564     for( f = p_chain->first; f != p_chain->last; f = f->next )
565     {
566         if( !IsInternalVideoAllocator( f ) )
567         {
568             AllocatorClean( &p_chain->allocator, f );
569
570             AllocatorInit( &internal_video_allocator, f );
571         }
572     }
573
574     if( f != NULL )
575     {
576         if( IsInternalVideoAllocator( f ) )
577         {
578             AllocatorClean( &internal_video_allocator, f );
579
580             if( AllocatorInit( &p_chain->allocator, f ) )
581                 return VLC_EGENERIC;
582         }
583     }
584     return VLC_SUCCESS;
585 }
586
587 /**
588  * This function should be called after every filter chain change
589  */
590 static int UpdateBufferFunctions( filter_chain_t *p_chain )
591 {
592     if( !strcmp( p_chain->psz_capability, "video filter2" ) )
593         return UpdateVideoBufferFunctions( p_chain );
594
595     return VLC_SUCCESS;
596 }
597
598 /* Internal video allocator functions */
599 static picture_t *VideoBufferNew( filter_t *p_filter )
600 {
601     const video_format_t *p_fmt = &p_filter->fmt_out.video;
602
603     picture_t *p_picture = picture_NewFromFormat( p_fmt );
604     if( !p_picture )
605         msg_Err( p_filter, "Failed to allocate picture" );
606     return p_picture;
607 }
608 static void VideoBufferDelete( filter_t *p_filter, picture_t *p_picture )
609 {
610     VLC_UNUSED( p_filter );
611     picture_Release( p_picture );
612 }
613 static int InternalVideoInit( filter_t *p_filter, void *p_data )
614 {
615     VLC_UNUSED(p_data);
616
617     p_filter->owner.video.buffer_new = VideoBufferNew;
618     p_filter->owner.video.buffer_del = VideoBufferDelete;
619
620     return VLC_SUCCESS;
621 }
622
623 static bool IsInternalVideoAllocator( chained_filter_t *p_filter )
624 {
625     return p_filter->filter.owner.video.buffer_new == VideoBufferNew;
626 }
627
628 /* */
629 static int AllocatorInit( const filter_chain_allocator_t *p_alloc,
630                           chained_filter_t *p_filter )
631 {
632     if( p_alloc->pf_init )
633         return p_alloc->pf_init( &p_filter->filter, p_alloc->p_data );
634     return VLC_SUCCESS;
635 }
636
637 static void AllocatorClean( const filter_chain_allocator_t *p_alloc,
638                             chained_filter_t *p_filter )
639 {
640     if( p_alloc->pf_clean )
641         p_alloc->pf_clean( &p_filter->filter );
642 }
643