c9b56a07baae7aa8fe64e8952eaeabd9b0853259
[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, spu_t *spu,
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         if( p_subpic )
346             spu_PutSubpicture( spu, p_subpic );
347     }
348 }
349
350 subpicture_t *filter_chain_SubFilter( filter_chain_t *p_chain, subpicture_t *p_subpic )
351 {
352     for( chained_filter_t *f = p_chain->first; f != NULL; f = f->next )
353     {
354         filter_t *p_filter = &f->filter;
355
356         p_subpic = p_filter->pf_sub_filter( p_filter, p_subpic );
357
358         if( !p_subpic )
359             break;
360     }
361     return p_subpic;
362 }
363
364 int filter_chain_MouseFilter( filter_chain_t *p_chain, vlc_mouse_t *p_dst, const vlc_mouse_t *p_src )
365 {
366     vlc_mouse_t current = *p_src;
367
368     for( chained_filter_t *f = p_chain->last; f != NULL; f = f->prev )
369     {
370         filter_t *p_filter = &f->filter;
371         vlc_mouse_t *p_mouse = f->mouse;
372
373         if( p_filter->pf_video_mouse && p_mouse )
374         {
375             vlc_mouse_t old = *p_mouse;
376             vlc_mouse_t filtered;
377
378             *p_mouse = current;
379             if( p_filter->pf_video_mouse( p_filter, &filtered, &old, &current ) )
380                 return VLC_EGENERIC;
381             current = filtered;
382         }
383     }
384
385     *p_dst = current;
386     return VLC_SUCCESS;
387 }
388
389 int filter_chain_MouseEvent( filter_chain_t *p_chain,
390                              const vlc_mouse_t *p_mouse,
391                              const video_format_t *p_fmt )
392 {
393     for( chained_filter_t *f = p_chain->first; f != NULL; f = f->next )
394     {
395         filter_t *p_filter = &f->filter;
396
397         if( p_filter->pf_sub_mouse )
398         {
399             vlc_mouse_t old = *f->mouse;
400             *f->mouse = *p_mouse;
401             if( p_filter->pf_sub_mouse( p_filter, &old, p_mouse, p_fmt ) )
402                 return VLC_EGENERIC;
403         }
404     }
405
406     return VLC_SUCCESS;
407 }
408
409 /* Helpers */
410 static filter_t *filter_chain_AppendFilterInternal( filter_chain_t *p_chain,
411                                                     const char *psz_name,
412                                                     config_chain_t *p_cfg,
413                                                     const es_format_t *p_fmt_in,
414                                                     const es_format_t *p_fmt_out )
415 {
416     chained_filter_t *p_chained =
417         vlc_custom_create( p_chain->p_this, sizeof(*p_chained), "filter" );
418     filter_t *p_filter = &p_chained->filter;
419     if( !p_filter )
420         return NULL;
421
422     if( !p_fmt_in )
423     {
424         if( p_chain->last != NULL )
425             p_fmt_in = &p_chain->last->filter.fmt_out;
426         else
427             p_fmt_in = &p_chain->fmt_in;
428     }
429
430     if( !p_fmt_out )
431     {
432         p_fmt_out = &p_chain->fmt_out;
433     }
434
435     es_format_Copy( &p_filter->fmt_in, p_fmt_in );
436     es_format_Copy( &p_filter->fmt_out, p_fmt_out );
437     p_filter->p_cfg = p_cfg;
438     p_filter->b_allow_fmt_out_change = p_chain->b_allow_fmt_out_change;
439
440     p_filter->p_module = module_need( p_filter, p_chain->psz_capability,
441                                       psz_name, psz_name != NULL );
442
443     if( !p_filter->p_module )
444         goto error;
445
446     if( p_filter->b_allow_fmt_out_change )
447     {
448         es_format_Clean( &p_chain->fmt_out );
449         es_format_Copy( &p_chain->fmt_out, &p_filter->fmt_out );
450     }
451
452     if( AllocatorInit( &p_chain->allocator, p_chained ) )
453         goto error;
454
455     if( p_chain->last == NULL )
456     {
457         assert( p_chain->first == NULL );
458         p_chain->first = p_chained;
459     }
460     else
461         p_chain->last->next = p_chained;
462     p_chained->prev = p_chain->last;
463     p_chain->last = p_chained;
464     p_chained->next = NULL;
465     p_chain->length++;
466
467     vlc_mouse_t *p_mouse = malloc( sizeof(*p_mouse) );
468     if( p_mouse )
469         vlc_mouse_Init( p_mouse );
470     p_chained->mouse = p_mouse;
471     p_chained->pending = NULL;
472
473     msg_Dbg( p_chain->p_this, "Filter '%s' (%p) appended to chain",
474              psz_name ? psz_name : module_get_name(p_filter->p_module, false),
475              p_filter );
476
477     return p_filter;
478
479 error:
480     if( psz_name )
481         msg_Err( p_chain->p_this, "Failed to create %s '%s'",
482                  p_chain->psz_capability, psz_name );
483     else
484         msg_Err( p_chain->p_this, "Failed to create %s",
485                  p_chain->psz_capability );
486     if( p_filter->p_module )
487         module_unneed( p_filter, p_filter->p_module );
488     es_format_Clean( &p_filter->fmt_in );
489     es_format_Clean( &p_filter->fmt_out );
490     vlc_object_release( p_filter );
491     return NULL;
492 }
493
494 static int filter_chain_DeleteFilterInternal( filter_chain_t *p_chain,
495                                               filter_t *p_filter )
496 {
497     chained_filter_t *p_chained = chained( p_filter );
498
499     /* Remove it from the chain */
500     if( p_chained->prev != NULL )
501         p_chained->prev->next = p_chained->next;
502     else
503     {
504         assert( p_chained == p_chain->first );
505         p_chain->first = p_chained->next;
506     }
507
508     if( p_chained->next != NULL )
509         p_chained->next->prev = p_chained->prev;
510     else
511     {
512         assert( p_chained == p_chain->last );
513         p_chain->last = p_chained->prev;
514     }
515     p_chain->length--;
516
517     msg_Dbg( p_chain->p_this, "Filter %p removed from chain", p_filter );
518
519     FilterDeletePictures( &p_chained->filter, p_chained->pending );
520
521     /* Destroy the filter object */
522     if( IsInternalVideoAllocator( p_chained ) )
523         AllocatorClean( &internal_video_allocator, p_chained );
524     else
525         AllocatorClean( &p_chain->allocator, p_chained );
526
527     if( p_filter->p_module )
528         module_unneed( p_filter, p_filter->p_module );
529     free( p_chained->mouse );
530     vlc_object_release( p_filter );
531
532
533     /* FIXME: check fmt_in/fmt_out consitency */
534     return VLC_SUCCESS;
535 }
536
537 static void FilterDeletePictures( filter_t *filter, picture_t *picture )
538 {
539     while( picture )
540     {
541         picture_t *next = picture->p_next;
542         filter_DeletePicture( filter, picture );
543         picture = next;
544     }
545 }
546
547 /**
548  * Internal chain buffer handling
549  */
550
551 static int UpdateVideoBufferFunctions( filter_chain_t *p_chain )
552 {
553     /**
554      * Last filter uses the filter chain's parent buffer allocation
555      * functions. All the other filters use internal functions.
556      * This makes it possible to have format changes between each
557      * filter without having to worry about the parent's picture
558      * heap format.
559      */
560     /* FIXME: we should only update the last and penultimate filters */
561     chained_filter_t *f;
562
563     for( f = p_chain->first; f != p_chain->last; f = f->next )
564     {
565         if( !IsInternalVideoAllocator( f ) )
566         {
567             AllocatorClean( &p_chain->allocator, f );
568
569             AllocatorInit( &internal_video_allocator, f );
570         }
571     }
572
573     if( f != NULL )
574     {
575         if( IsInternalVideoAllocator( f ) )
576         {
577             AllocatorClean( &internal_video_allocator, f );
578
579             if( AllocatorInit( &p_chain->allocator, f ) )
580                 return VLC_EGENERIC;
581         }
582     }
583     return VLC_SUCCESS;
584 }
585
586 /**
587  * This function should be called after every filter chain change
588  */
589 static int UpdateBufferFunctions( filter_chain_t *p_chain )
590 {
591     if( !strcmp( p_chain->psz_capability, "video filter2" ) )
592         return UpdateVideoBufferFunctions( p_chain );
593
594     return VLC_SUCCESS;
595 }
596
597 /* Internal video allocator functions */
598 static picture_t *VideoBufferNew( filter_t *p_filter )
599 {
600     const video_format_t *p_fmt = &p_filter->fmt_out.video;
601
602     picture_t *p_picture = picture_NewFromFormat( p_fmt );
603     if( !p_picture )
604         msg_Err( p_filter, "Failed to allocate picture" );
605     return p_picture;
606 }
607 static void VideoBufferDelete( filter_t *p_filter, picture_t *p_picture )
608 {
609     VLC_UNUSED( p_filter );
610     picture_Release( p_picture );
611 }
612 static int InternalVideoInit( filter_t *p_filter, void *p_data )
613 {
614     VLC_UNUSED(p_data);
615
616     p_filter->owner.video.buffer_new = VideoBufferNew;
617     p_filter->owner.video.buffer_del = VideoBufferDelete;
618
619     return VLC_SUCCESS;
620 }
621
622 static bool IsInternalVideoAllocator( chained_filter_t *p_filter )
623 {
624     return p_filter->filter.owner.video.buffer_new == VideoBufferNew;
625 }
626
627 /* */
628 static int AllocatorInit( const filter_chain_allocator_t *p_alloc,
629                           chained_filter_t *p_filter )
630 {
631     if( p_alloc->pf_init )
632         return p_alloc->pf_init( &p_filter->filter, p_alloc->p_data );
633     return VLC_SUCCESS;
634 }
635
636 static void AllocatorClean( const filter_chain_allocator_t *p_alloc,
637                             chained_filter_t *p_filter )
638 {
639     if( p_alloc->pf_clean )
640         p_alloc->pf_clean( &p_filter->filter );
641 }
642