dynamicoverlay: use filter_NewSubpicture()
[vlc.git] / modules / video_filter / dynamicoverlay / dynamicoverlay.c
1 /*****************************************************************************
2  * dynamicoverlay.c : dynamic overlay plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2007 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Author: Søren Bøg <avacore@videolan.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 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <vlc_common.h>
32 #include <vlc_plugin.h>
33 #include <vlc_sout.h>
34 #include <vlc_vout.h>
35 #include <vlc_filter.h>
36 #include <vlc_fs.h>
37
38 #include <ctype.h>
39 #include <fcntl.h>
40 #include <errno.h>
41 #include <unistd.h>
42
43 #include "dynamicoverlay.h"
44
45 /*****************************************************************************
46  * Local prototypes
47  *****************************************************************************/
48 static int Create( vlc_object_t * );
49 static void Destroy( vlc_object_t * );
50 static subpicture_t *Filter( filter_t *, mtime_t );
51
52 static int AdjustCallback( vlc_object_t *p_this, char const *psz_var,
53                            vlc_value_t oldval, vlc_value_t newval,
54                            void *p_data );
55
56 /*****************************************************************************
57  * Module descriptor
58  *****************************************************************************/
59
60 #define INPUT_TEXT N_("Input FIFO")
61 #define INPUT_LONGTEXT N_("FIFO which will be read for commands")
62
63 #define OUTPUT_TEXT N_("Output FIFO")
64 #define OUTPUT_LONGTEXT N_("FIFO which will be written to for responses")
65
66 vlc_module_begin ()
67     set_description( N_("Dynamic video overlay") )
68     set_shortname( N_("Overlay" ))
69     set_category( CAT_VIDEO )
70     set_subcategory( SUBCAT_VIDEO_VFILTER )
71     set_capability( "sub source", 0 )
72
73     add_loadfile( "overlay-input", NULL, INPUT_TEXT, INPUT_LONGTEXT,
74                   false )
75     /* Note: add_loadfile as O_WRONLY w/o O_CREAT, i.e. FIFO must exist */
76     add_loadfile( "overlay-output", NULL, OUTPUT_TEXT, OUTPUT_LONGTEXT,
77                   false )
78
79     add_shortcut( "overlay" )
80     set_callbacks( Create, Destroy )
81 vlc_module_end ()
82
83 static const char *const ppsz_filter_options[] = {
84     "input", "output", NULL
85 };
86
87 /*****************************************************************************
88  * Create: allocates adjust video thread output method
89  *****************************************************************************
90  * This function allocates and initializes a adjust vout method.
91  *****************************************************************************/
92 static int Create( vlc_object_t *p_this )
93 {
94     filter_t *p_filter = (filter_t *)p_this;
95     filter_sys_t *p_sys;
96
97     /* Allocate structure */
98     p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
99     if( p_filter->p_sys == NULL )
100         return VLC_ENOMEM;
101     p_sys = p_filter->p_sys;
102
103     BufferInit( &p_sys->input );
104     BufferInit( &p_sys->output );
105     QueueInit( &p_sys->atomic );
106     QueueInit( &p_sys->pending );
107     QueueInit( &p_sys->processed );
108     do_ListInit( &p_sys->overlays );
109
110     p_sys->i_inputfd = -1;
111     p_sys->i_outputfd = -1;
112     p_sys->b_updated = true;
113     p_sys->b_atomic = false;
114     vlc_mutex_init( &p_sys->lock );
115
116     p_filter->pf_sub_source = Filter;
117
118     config_ChainParse( p_filter, "overlay-", ppsz_filter_options,
119                        p_filter->p_cfg );
120
121     p_sys->psz_inputfile = var_CreateGetStringCommand( p_filter,
122                                                        "overlay-input" );
123     p_sys->psz_outputfile = var_CreateGetStringCommand( p_filter,
124                                                         "overlay-output" );
125
126     var_AddCallback( p_filter, "overlay-input", AdjustCallback, p_sys );
127     var_AddCallback( p_filter, "overlay-output", AdjustCallback, p_sys );
128
129     RegisterCommand( p_filter );
130     return VLC_SUCCESS;
131 }
132
133 /*****************************************************************************
134  * Destroy: destroy adjust video thread output method
135  *****************************************************************************
136  * Terminate an output method created by adjustCreateOutputMethod
137  *****************************************************************************/
138 static void Destroy( vlc_object_t *p_this )
139 {
140     filter_t *p_filter = (filter_t *)p_this;
141     filter_sys_t *p_sys = p_filter->p_sys;
142
143     BufferDestroy( &p_sys->input );
144     BufferDestroy( &p_sys->output );
145     QueueDestroy( &p_sys->atomic );
146     QueueDestroy( &p_sys->pending );
147     QueueDestroy( &p_sys->processed );
148     do_ListDestroy( &p_sys->overlays );
149     UnregisterCommand( p_filter );
150
151     var_DelCallback( p_filter, "overlay-input", AdjustCallback, p_sys );
152     var_DelCallback( p_filter, "overlay-output", AdjustCallback, p_sys );
153
154     vlc_mutex_destroy( &p_sys->lock );
155     free( p_sys->psz_inputfile );
156     free( p_sys->psz_outputfile );
157     free( p_sys );
158 }
159
160 /*****************************************************************************
161  * Render: displays previously rendered output
162  *****************************************************************************
163  * This function send the currently rendered image to adjust modified image,
164  * waits until it is displayed and switch the two rendering buffers, preparing
165  * next frame.
166  *****************************************************************************/
167 static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
168 {
169     filter_sys_t *p_sys = p_filter->p_sys;
170
171     /* We might need to open these at any time. */
172     vlc_mutex_lock( &p_sys->lock );
173     if( p_sys->i_inputfd == -1 )
174     {
175         p_sys->i_inputfd = vlc_open( p_sys->psz_inputfile, O_RDONLY | O_NONBLOCK );
176         if( p_sys->i_inputfd == -1 )
177         {
178             msg_Warn( p_filter, "Failed to grab input file: %s (%s)",
179                       p_sys->psz_inputfile, vlc_strerror_c(errno) );
180         }
181         else
182         {
183             msg_Info( p_filter, "Grabbed input file: %s",
184                       p_sys->psz_inputfile );
185         }
186     }
187
188     if( p_sys->i_outputfd == -1 )
189     {
190         p_sys->i_outputfd = vlc_open( p_sys->psz_outputfile,
191                                   O_WRONLY | O_NONBLOCK );
192         if( p_sys->i_outputfd == -1 )
193         {
194             if( errno != ENXIO )
195             {
196                 msg_Warn( p_filter, "Failed to grab output file: %s (%s)",
197                           p_sys->psz_outputfile, vlc_strerror_c(errno) );
198             }
199         }
200         else
201         {
202             msg_Info( p_filter, "Grabbed output file: %s",
203                       p_sys->psz_outputfile );
204         }
205     }
206     vlc_mutex_unlock( &p_sys->lock );
207
208     /* Read any waiting commands */
209     if( p_sys->i_inputfd != -1 )
210     {
211         char p_buffer[1024];
212         ssize_t i_len = read( p_sys->i_inputfd, p_buffer, 1024 );
213         if( i_len == -1 )
214         {
215             /* We hit an error */
216             if( errno != EAGAIN )
217             {
218                 msg_Warn( p_filter, "Error on input file: %s",
219                           vlc_strerror_c(errno) );
220                 close( p_sys->i_inputfd );
221                 p_sys->i_inputfd = -1;
222             }
223         }
224         else if( i_len == 0 )
225         {
226             /* We hit the end-of-file */
227         }
228         else
229         {
230             BufferAdd( &p_sys->input, p_buffer, i_len );
231         }
232     }
233
234     /* Parse any complete commands */
235     char *p_end, *p_cmd;
236     while( ( p_end = memchr( p_sys->input.p_begin, '\n',
237                              p_sys->input.i_length ) ) )
238     {
239         commanddesc_t *p_cur = NULL;
240         bool b_found = false;
241         size_t i_index = 0;
242
243         *p_end = '\0';
244         p_cmd = BufferGetToken( &p_sys->input );
245
246         msg_Info( p_filter, "Search command: %s", p_cmd );
247         for( i_index = 0; i_index < p_sys->i_commands; i_index++ )
248         {
249             p_cur = p_sys->pp_commands[i_index];
250             if( !strncmp( p_cur->psz_command, p_cmd, strlen(p_cur->psz_command) ) )
251             {
252                 p_cmd[strlen(p_cur->psz_command)] = '\0';
253                 b_found = true;
254                 break;
255             }
256         }
257
258         if( !b_found )
259         {
260             /* No matching command */
261             msg_Err( p_filter, "Got invalid command: %s", p_cmd );
262             BufferPrintf( &p_sys->output, "FAILURE: %d Invalid Command\n", VLC_EGENERIC );
263         }
264         else
265         {
266             msg_Info( p_filter, "Got valid command: %s", p_cmd );
267
268             command_t *p_cmddesc = malloc( sizeof( command_t ) );
269             if( !p_cmddesc )
270                 return NULL;
271
272             p_cmd = p_cmd + strlen(p_cur->psz_command) +1;
273             p_cmddesc->p_command = p_cur;
274             p_cmddesc->p_command->pf_parser( p_cmd, p_end,
275                                              &p_cmddesc->params );
276
277             if( p_cmddesc->p_command->b_atomic && p_sys->b_atomic )
278                 QueueEnqueue( &p_sys->atomic, p_cmddesc );
279             else
280                 QueueEnqueue( &p_sys->pending, p_cmddesc );
281         }
282
283         BufferDel( &p_sys->input, p_end - p_sys->input.p_begin + 1 );
284     }
285
286     /* Process any pending commands */
287     command_t *p_command = NULL;
288     while( (p_command = QueueDequeue( &p_sys->pending )) )
289     {
290         p_command->i_status =
291             p_command->p_command->pf_execute( p_filter, &p_command->params,
292                                               &p_command->results );
293         QueueEnqueue( &p_sys->processed, p_command );
294     }
295
296     /* Output any processed commands */
297     while( (p_command = QueueDequeue( &p_sys->processed )) )
298     {
299         if( p_command->i_status == VLC_SUCCESS )
300         {
301             const char *psz_success = "SUCCESS:";
302             const char *psz_nl = "\n";
303             BufferAdd( &p_sys->output, psz_success, 8 );
304             p_command->p_command->pf_unparse( &p_command->results,
305                                               &p_sys->output );
306             BufferAdd( &p_sys->output, psz_nl, 1 );
307         }
308         else
309         {
310             BufferPrintf( &p_sys->output, "FAILURE: %d\n",
311                           p_command->i_status );
312         }
313     }
314
315     /* Try emptying the output buffer */
316     if( p_sys->i_outputfd != -1 )
317     {
318         ssize_t i_len = write( p_sys->i_outputfd, p_sys->output.p_begin,
319                               p_sys->output.i_length );
320         if( i_len == -1 )
321         {
322             /* We hit an error */
323             if( errno != EAGAIN )
324             {
325                 msg_Warn( p_filter, "Error on output file: %s",
326                           vlc_strerror_c(errno) );
327                 close( p_sys->i_outputfd );
328                 p_sys->i_outputfd = -1;
329             }
330         }
331         else
332         {
333             BufferDel( &p_sys->output, i_len );
334         }
335     }
336
337     if( !p_sys->b_updated )
338         return NULL;
339
340     subpicture_t *p_spu = NULL;
341     overlay_t *p_overlay = NULL;
342
343     p_spu = filter_NewSubpicture( p_filter );
344     if( !p_spu )
345         return NULL;
346
347     p_spu->b_absolute = true;
348     p_spu->i_start = date;
349     p_spu->i_stop = 0;
350     p_spu->b_ephemer = true;
351
352     subpicture_region_t **pp_region = &p_spu->p_region;
353     while( (p_overlay = ListWalk( &p_sys->overlays )) )
354     {
355         subpicture_region_t *p_region;
356
357         *pp_region = p_region = subpicture_region_New( &p_overlay->format );
358         if( !p_region )
359             break;
360
361         msg_Dbg( p_filter, "Displaying overlay: %4.4s, %d, %d, %d",
362                  (char*)&p_overlay->format.i_chroma, p_overlay->i_x, p_overlay->i_y,
363                  p_overlay->i_alpha );
364
365         if( p_overlay->format.i_chroma == VLC_CODEC_TEXT )
366         {
367             p_region->psz_text = strdup( p_overlay->data.p_text );
368             p_region->p_style = text_style_Duplicate( p_overlay->p_fontstyle );
369         }
370         else
371         {
372             /* FIXME the copy is probably not needed anymore */
373             picture_Copy( p_region->p_picture, p_overlay->data.p_pic );
374         }
375         p_region->i_x = p_overlay->i_x;
376         p_region->i_y = p_overlay->i_y;
377         p_region->i_align = SUBPICTURE_ALIGN_LEFT | SUBPICTURE_ALIGN_TOP;
378         p_region->i_alpha = p_overlay->i_alpha;
379         pp_region = &p_region->p_next;
380     }
381
382     p_sys->b_updated = false;
383     return p_spu;
384 }
385
386 static int AdjustCallback( vlc_object_t *p_this, char const *psz_var,
387                            vlc_value_t oldval, vlc_value_t newval,
388                            void *p_data )
389 {
390     filter_sys_t *p_sys = (filter_sys_t *)p_data;
391     VLC_UNUSED(p_this); VLC_UNUSED(oldval);
392
393     vlc_mutex_lock( &p_sys->lock );
394     if( !strncmp( psz_var, "overlay-input", 13 ) )
395     {
396         free( p_sys->psz_inputfile );
397         p_sys->psz_inputfile = strdup( newval.psz_string );
398     }
399     else if( !strncmp( psz_var, "overlay-output", 14 ) )
400     {
401         free( p_sys->psz_outputfile );
402         p_sys->psz_outputfile = strdup( newval.psz_string );
403     }
404     vlc_mutex_unlock( &p_sys->lock );
405
406     return VLC_EGENERIC;
407 }