upnp: remove m_server_list_lock, p_server_list is already protected by s_lock
[vlc.git] / modules / video_filter / freeze.c
1 /*****************************************************************************
2  * freeze.c : Freezing video filter
3  *****************************************************************************
4  * Copyright (C) 2013      Vianney Boyer
5  * $Id$
6  *
7  * Authors: Vianney Boyer <vlcvboyer -at- gmail -dot- com>
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 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33 #include <vlc_plugin.h>
34 #include <vlc_filter.h>
35
36 #include "filter_picture.h"
37
38 #ifndef MOD
39 #   define MOD(a, b) ((((a)%(b)) + (b))%(b))
40 #endif
41
42 struct filter_sys_t {
43     bool b_init;
44
45     int32_t i_planes;
46     int32_t *i_height;
47     int32_t *i_width;
48     int32_t *i_visible_pitch;
49     int8_t  ***pi_freezed_picture;   /* records freezed pixels */
50     int16_t **pi_freezing_countdown; /* freezed pixel delay    */
51     bool    **pb_update_cache;       /* update chache request  */
52
53 };
54
55 /*****************************************************************************
56  * Prototypes
57  *****************************************************************************/
58
59 static picture_t *Filter( filter_t *, picture_t * );
60
61 static int  freeze_mouse( filter_t *, vlc_mouse_t *,
62                    const vlc_mouse_t *, const vlc_mouse_t * );
63 static int  freeze_allocate_data( filter_t *, picture_t * );
64 static void freeze_free_allocated_data( filter_t * );
65
66
67 /*****************************************************************************
68  * Module descriptor
69  *****************************************************************************/
70
71 #define CFG_PREFIX "freeze-"
72
73 static int  Open ( vlc_object_t * );
74 static void Close( vlc_object_t * );
75
76 vlc_module_begin()
77     set_description( N_("Freezing interactive video filter") )
78     set_shortname(   N_("Freeze" ) )
79     set_capability(  "video filter2", 0 )
80     set_category(    CAT_VIDEO )
81     set_subcategory( SUBCAT_VIDEO_VFILTER )
82
83     set_callbacks( Open, Close )
84 vlc_module_end()
85
86 /*****************************************************************************
87  * Local prototypes
88  *****************************************************************************/
89
90 /**
91  * Open the filter
92  */
93 static int Open( vlc_object_t *p_this )
94 {
95     filter_t *p_filter = (filter_t *)p_this;
96     filter_sys_t *p_sys;
97
98     /* Assert video in match with video out */
99     if( !es_format_IsSimilar( &p_filter->fmt_in, &p_filter->fmt_out ) ) {
100         msg_Err( p_filter, "Input and output format does not match" );
101         return VLC_EGENERIC;
102     }
103
104     /* Reject 0 bpp and unsupported chroma */
105     const vlc_fourcc_t fourcc = p_filter->fmt_in.video.i_chroma;
106     const vlc_chroma_description_t *p_chroma
107           = vlc_fourcc_GetChromaDescription( p_filter->fmt_in.video.i_chroma );
108     if( !p_chroma || p_chroma->pixel_size == 0
109         || p_chroma->plane_count < 3 || p_chroma->pixel_size > 1
110         || !vlc_fourcc_IsYUV( fourcc ) )
111     {
112         msg_Err( p_filter, "Unsupported chroma (%4.4s)", (char*)&fourcc );
113         return VLC_EGENERIC;
114     }
115
116     /* Allocate structure */
117     p_filter->p_sys = p_sys = calloc(1, sizeof( *p_sys ) );
118     if( unlikely(!p_sys) )
119         return VLC_ENOMEM;
120
121     /* init data */
122
123     p_filter->pf_video_filter = Filter;
124     p_filter->pf_video_mouse  = freeze_mouse;
125
126     return VLC_SUCCESS;
127 }
128
129 /**
130  * Close the filter
131  */
132 static void Close( vlc_object_t *p_this ) {
133     filter_t *p_filter  = (filter_t *)p_this;
134     filter_sys_t *p_sys = p_filter->p_sys;
135
136     /* Free allocated memory */
137     freeze_free_allocated_data( p_filter );
138     free( p_sys );
139 }
140
141 /**
142  * Filter a picture
143  */
144 static picture_t *Filter( filter_t *p_filter, picture_t *p_pic_in ) {
145     if( !p_pic_in || !p_filter) return NULL;
146
147     filter_sys_t *p_sys = p_filter->p_sys;
148
149     picture_t *p_pic_out = filter_NewPicture( p_filter );
150     if( unlikely(!p_pic_out) ) {
151         picture_Release( p_pic_in );
152         return NULL;
153     }
154
155    /*
156     * allocate data
157     */
158     if ( unlikely(!p_sys->b_init) )
159         if (freeze_allocate_data( p_filter, p_pic_in ) != VLC_SUCCESS)
160         {
161             picture_Release( p_pic_in );
162             return NULL;
163         }
164     p_sys->b_init = true;
165
166    /*
167     * preset output pic: raw copy src to dst
168     */
169     picture_CopyPixels(p_pic_out, p_pic_in);
170
171    /*
172     * cache original pict pixels selected with mouse pointer
173     */
174     for ( int32_t i_p = 0; i_p < p_sys->i_planes; i_p++ )
175         for ( int32_t i_r = 0; i_r < p_sys->i_height[i_p]; i_r++ )
176             for ( int32_t i_c = 0; i_c < p_sys->i_width[i_p]; i_c++ )
177             {
178                 uint32_t i_Yr = i_r * p_sys->i_height[Y_PLANE]
179                               / p_sys->i_height[i_p];
180                 uint32_t i_Yc = i_c * p_sys->i_width[Y_PLANE]
181                               / p_sys->i_width[i_p];
182
183                 if ( p_sys->pb_update_cache[i_Yr][i_Yc] )
184                     p_sys->pi_freezed_picture[i_p][i_r][i_c]
185                         = p_pic_in->p[i_p].p_pixels[i_r*p_pic_out->p[i_p].i_pitch
186                         + i_c*p_pic_out->p[i_p].i_pixel_pitch];
187             }
188
189    /*
190     * countdown freezed pixel delay & reset pb_update_cache flag
191     */
192     for ( int32_t i_Yr = 0; i_Yr < p_sys->i_height[Y_PLANE]; i_Yr++)
193         for ( int32_t i_Yc = 0; i_Yc < p_sys->i_width[Y_PLANE]; i_Yc++)
194         {
195             if ( p_sys->pi_freezing_countdown[i_Yr][i_Yc] > 0 )
196                  p_sys->pi_freezing_countdown[i_Yr][i_Yc]--;
197             p_sys->pb_update_cache[i_Yr][i_Yc] = false;
198         }
199
200    /*
201     * apply filter: draw freezed pixels over current picture
202     */
203     for ( int32_t i_p = 0; i_p < p_sys->i_planes; i_p++ )
204         for ( int32_t i_r = 0; i_r < p_sys->i_height[i_p]; i_r++ )
205             for ( int32_t i_c = 0; i_c < p_sys->i_width[i_p]; i_c++ )
206             {
207                 uint32_t i_Yr = i_r * p_sys->i_height[Y_PLANE]
208                               / p_sys->i_height[i_p];
209                 uint32_t i_Yc = i_c * p_sys->i_width[Y_PLANE]
210                               / p_sys->i_width[i_p];
211
212                 if ( p_sys->pi_freezing_countdown[i_Yr][i_Yc] > 0 )
213                     p_pic_out->p[i_p].p_pixels[i_r * p_pic_out->p[i_p].i_pitch
214                         + i_c * p_pic_out->p[i_p].i_pixel_pitch]
215                         = p_sys->pi_freezed_picture[i_p][i_r][i_c];
216             }
217
218     return CopyInfoAndRelease( p_pic_out, p_pic_in );
219 }
220
221 /*
222  * mouse callback
223  **/
224 static int freeze_mouse( filter_t *p_filter, vlc_mouse_t *p_mouse,
225                   const vlc_mouse_t *p_old, const vlc_mouse_t *p_new )
226 {
227     filter_sys_t *p_sys = p_filter->p_sys;
228     const video_format_t  *p_fmt_in = &p_filter->fmt_in.video;
229
230     /* Only take events inside the video area */
231     if( p_new->i_x < 0 || p_new->i_x >= (int)p_fmt_in->i_width ||
232         p_new->i_y < 0 || p_new->i_y >= (int)p_fmt_in->i_height )
233         return VLC_EGENERIC;
234
235     if ( unlikely(!p_sys->b_init) )
236     {
237         *p_mouse = *p_new;
238         return VLC_SUCCESS;
239     }
240
241     int32_t i_base_timeout = 0;
242     if( vlc_mouse_HasPressed( p_old, p_new, MOUSE_BUTTON_LEFT ) )
243         i_base_timeout = 100;
244     else if( vlc_mouse_IsLeftPressed( p_new ) )
245         i_base_timeout = 50;
246
247     if( i_base_timeout > 0 )
248     {
249         /*
250          * find pixels selected by user to apply freezing filter
251          */
252         int32_t i_min_sq_radius = (p_sys->i_width[Y_PLANE] / 15)
253                                 * (p_sys->i_width[Y_PLANE] / 15);
254         for ( int32_t i_r = 0; i_r < p_sys->i_height[Y_PLANE]; i_r++)
255             for ( int32_t i_c = 0; i_c < p_sys->i_width[Y_PLANE]; i_c++)
256             {
257                 int32_t i_sq_dist =   ( p_new->i_x - i_c )
258                                     * ( p_new->i_x - i_c )
259                                     + ( p_new->i_y - i_r )
260                                     * ( p_new->i_y - i_r );
261                 i_sq_dist = __MAX(0, i_sq_dist - i_min_sq_radius);
262
263                 uint16_t i_timeout = __MAX(i_base_timeout - i_sq_dist, 0);
264
265                 /* ask to update chache for pixel to be freezed just now */
266                 if ( p_sys->pi_freezing_countdown[i_r][i_c] == 0 && i_timeout > 0)
267                      p_sys->pb_update_cache[i_r][i_c] = true;
268
269                 /* set freezing delay */
270                 if ( p_sys->pi_freezing_countdown[i_r][i_c] < i_timeout )
271                      p_sys->pi_freezing_countdown[i_r][i_c] = i_timeout;
272             }
273     }
274
275     return VLC_EGENERIC;
276 }
277
278
279 /*
280  * Allocate data
281  */
282 static int freeze_allocate_data( filter_t *p_filter, picture_t *p_pic_in )
283 {
284     filter_sys_t *p_sys = p_filter->p_sys;
285
286     freeze_free_allocated_data( p_filter );
287
288    /*
289     * take into account different characteristics for each plane
290     */
291     p_sys->i_planes        = p_pic_in->i_planes;
292     p_sys->i_height        = calloc( p_sys->i_planes, sizeof(int32_t) );
293     p_sys->i_width         = calloc( p_sys->i_planes, sizeof(int32_t) );
294     p_sys->i_visible_pitch = calloc( p_sys->i_planes, sizeof(int32_t) );
295
296     if ( unlikely( !p_sys->i_height || !p_sys->i_width || !p_sys->i_visible_pitch ) )
297     {
298         freeze_free_allocated_data( p_filter );
299         return VLC_ENOMEM;
300     }
301
302     /* init data */
303     for ( int32_t i_p = 0; i_p < p_sys->i_planes; i_p++ )
304     {
305         p_sys->i_visible_pitch [i_p] = (int) p_pic_in->p[i_p].i_visible_pitch;
306         p_sys->i_height[i_p]         = (int) p_pic_in->p[i_p].i_visible_lines;
307         p_sys->i_width[i_p]          = (int) p_pic_in->p[i_p].i_visible_pitch
308                                      / p_pic_in->p[i_p].i_pixel_pitch;
309     }
310
311     /* buffer used to countdown freezing delay */
312     p_sys->pi_freezing_countdown
313         = calloc( p_sys->i_height[Y_PLANE], sizeof(int16_t*) );
314     if ( unlikely( !p_sys->pi_freezing_countdown ) )
315     {
316         freeze_free_allocated_data( p_filter );
317         return VLC_ENOMEM;
318     }
319
320     for ( int32_t i_r = 0; i_r < p_sys->i_height[Y_PLANE]; i_r++ )
321     {
322         p_sys->pi_freezing_countdown[i_r]
323             = calloc( p_sys->i_width[Y_PLANE], sizeof(int16_t) );
324         if ( unlikely( !p_sys->pi_freezing_countdown[i_r] ) )
325         {
326             freeze_free_allocated_data( p_filter );
327             return VLC_ENOMEM;
328         }
329     }
330
331     /* buffer used to cache freezed pixels colors */
332     p_sys->pi_freezed_picture = calloc( p_sys->i_planes, sizeof(int8_t**) );
333     if( unlikely( !p_sys->pi_freezed_picture ) )
334     {
335         freeze_free_allocated_data( p_filter );
336         return VLC_ENOMEM;
337     }
338
339     for ( int32_t i_p = 0; i_p < p_sys->i_planes; i_p++)
340     {
341         p_sys->pi_freezed_picture[i_p]
342             = calloc( p_sys->i_height[i_p], sizeof(int8_t*) );
343         if ( unlikely(!p_sys->pi_freezed_picture[i_p]) )
344         {
345             freeze_free_allocated_data( p_filter );
346             return VLC_ENOMEM;
347         }
348         for ( int32_t i_r = 0; i_r < p_sys->i_height[i_p]; i_r++ )
349         {
350             p_sys->pi_freezed_picture[i_p][i_r]
351                 = calloc( p_sys->i_width[i_p], sizeof(int8_t) );
352             if ( unlikely( !p_sys->pi_freezed_picture[i_p][i_r] ) )
353             {
354                 freeze_free_allocated_data( p_filter );
355                 return VLC_ENOMEM;
356             }
357         }
358     }
359
360     /* flag used to manage freezed pixels cache update */
361     p_sys->pb_update_cache
362         = calloc( p_sys->i_height[Y_PLANE], sizeof(bool*) );
363     if( unlikely( !p_sys->pb_update_cache ) )
364     {
365         freeze_free_allocated_data( p_filter );
366         return VLC_ENOMEM;
367     }
368
369     for ( int32_t i_r = 0; i_r < p_sys->i_height[Y_PLANE]; i_r++ )
370     {
371         p_sys->pb_update_cache[i_r]
372             = calloc( p_sys->i_width[Y_PLANE], sizeof(bool) );
373         if ( unlikely( !p_sys->pb_update_cache[i_r] ) )
374         {
375             freeze_free_allocated_data( p_filter );
376             return VLC_ENOMEM;
377         }
378     }
379
380     return VLC_SUCCESS;
381 }
382
383 /**
384  * Free allocated data
385  */
386 static void freeze_free_allocated_data( filter_t *p_filter ) {
387     filter_sys_t *p_sys = p_filter->p_sys;
388
389     if (p_sys->pi_freezing_countdown)
390         for ( int32_t i_r = 0; i_r < p_sys->i_height[Y_PLANE]; i_r++ )
391             free( p_sys->pi_freezing_countdown[i_r] );
392     FREENULL( p_sys->pi_freezing_countdown );
393
394     if ( p_sys->pb_update_cache )
395         for ( int32_t i_r = 0; i_r < p_sys->i_height[Y_PLANE]; i_r++ )
396             free( p_sys->pb_update_cache[i_r] );
397     FREENULL( p_sys->pb_update_cache );
398
399     if ( p_sys->pi_freezed_picture )
400         for ( int32_t i_p=0; i_p < p_sys->i_planes; i_p++ ) {
401             for ( int32_t i_r=0; i_r < p_sys->i_height[i_p]; i_r++ )
402                 free( p_sys->pi_freezed_picture[i_p][i_r] );
403             free( p_sys->pi_freezed_picture[i_p] );
404             }
405     FREENULL( p_sys->pi_freezed_picture );
406
407     p_sys->i_planes = 0;
408     FREENULL( p_sys->i_height );
409     FREENULL( p_sys->i_width );
410     FREENULL( p_sys->i_visible_pitch );
411 }