← Back to branch summary

~bratsche/vlc/vlc-notify-add-actions-with-server-support

« back to all changes in this revision

Viewing changes to modules/video_filter/dynamicoverlay/dynamicoverlay_commands.c

  • Committer: Bazaar Package Importer
  • Date: 2008-11-28 09:41:28 UTC
  • Revision ID: jamesw@ubuntu.com-20081128094128-qc1zhxqwlf2ov8cl
Tags: upstream-ubuntu-0.9.2
Import upstream version 0.9.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/video_filter/dynamicoverlay/dynamicoverlay_commands.c
 
1
/*****************************************************************************
 
2
 * dynamicoverlay_commands.c : dynamic overlay plugin commands
 
3
 *****************************************************************************
 
4
 * Copyright (C) 2008 the VideoLAN team
 
5
 * $Id$
 
6
 *
 
7
 * Author: Soren Bog <avacore@videolan.org>
 
8
 *         Jean-Paul Saman <jpsaman@videolan.org>
 
9
 *
 
10
 * This program is free software; you can redistribute it and/or modify
 
11
 * it under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation; either version 2 of the License, or
 
13
 * (at your option) any later version.
 
14
 *
 
15
 * This program is distributed in the hope that it will be useful,
 
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
18
 * GNU General Public License for more details.
 
19
 *
 
20
 * You should have received a copy of the GNU General Public License
 
21
 * along with this program; if not, write to the Free Software
 
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 
23
 *****************************************************************************/
 
24
 
 
25
#ifdef HAVE_CONFIG_H
 
26
# include "config.h"
 
27
#endif
 
28
 
 
29
#include <vlc_common.h>
 
30
#include <vlc_arrays.h>
 
31
#include <vlc_vout.h>
 
32
#include <vlc_filter.h>
 
33
#include <vlc_osd.h>
 
34
 
 
35
#include <string.h>
 
36
#include <ctype.h>
 
37
 
 
38
#if defined(HAVE_SYS_SHM_H)
 
39
#include <sys/shm.h>
 
40
#endif
 
41
 
 
42
#include "dynamicoverlay.h"
 
43
 
 
44
 
 
45
/*****************************************************************************
 
46
 * overlay_t: Overlay descriptor
 
47
 *****************************************************************************/
 
48
 
 
49
overlay_t *OverlayCreate( void )
 
50
{
 
51
    overlay_t *p_ovl = malloc( sizeof( overlay_t ) );
 
52
    if( p_ovl == NULL )
 
53
       return NULL;
 
54
    memset( p_ovl, 0, sizeof( overlay_t ) );
 
55
 
 
56
    p_ovl->i_x = p_ovl->i_y = 0;
 
57
    p_ovl->i_alpha = 0xFF;
 
58
    p_ovl->b_active = false;
 
59
    vout_InitFormat( &p_ovl->format, VLC_FOURCC( '\0','\0','\0','\0') , 0, 0,
 
60
                     VOUT_ASPECT_FACTOR );
 
61
    memcpy( &p_ovl->fontstyle, &default_text_style, sizeof(struct text_style_t) );
 
62
    p_ovl->data.p_text = NULL;
 
63
 
 
64
    return p_ovl;
 
65
}
 
66
 
 
67
int OverlayDestroy( overlay_t *p_ovl )
 
68
{
 
69
    if( p_ovl->data.p_text != NULL )
 
70
        free( p_ovl->data.p_text );
 
71
 
 
72
    return VLC_SUCCESS;
 
73
}
 
74
 
 
75
/*****************************************************************************
 
76
 * Command parsers
 
77
 *****************************************************************************/
 
78
static int skip_space( char **psz_command )
 
79
{
 
80
    char *psz_temp = *psz_command;
 
81
 
 
82
    while( isspace( *psz_temp ) )
 
83
    {
 
84
        ++psz_temp;
 
85
    }
 
86
    if( psz_temp == *psz_command )
 
87
    {
 
88
        return VLC_EGENERIC;
 
89
    }
 
90
    *psz_command = psz_temp;
 
91
    return VLC_SUCCESS;
 
92
}
 
93
 
 
94
static int parse_digit( char **psz_command, int32_t *value )
 
95
{
 
96
    char *psz_temp;
 
97
    *value = strtol( *psz_command, &psz_temp, 10 );
 
98
    if( psz_temp == *psz_command )
 
99
    {
 
100
        return VLC_EGENERIC;
 
101
    }
 
102
    *psz_command = psz_temp;
 
103
    return VLC_SUCCESS;
 
104
}
 
105
 
 
106
static int parse_char( char **psz_command, char **psz_end,
 
107
                       int count, char *psz_value )
 
108
{
 
109
    if( *psz_end - *psz_command < count )
 
110
    {
 
111
        return VLC_EGENERIC;
 
112
    }
 
113
    memcpy( psz_value, *psz_command, count );
 
114
    *psz_command += count;
 
115
    return VLC_SUCCESS;
 
116
}
 
117
 
 
118
static int parser_DataSharedMem( char *psz_command,
 
119
                                 char *psz_end,
 
120
                                 commandparams_t *p_params )
 
121
{
 
122
    /* Parse: 0 128 128 RGBA 9404459 */
 
123
    skip_space( &psz_command );
 
124
    if( isdigit( *psz_command ) )
 
125
    {
 
126
        if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
 
127
            return VLC_EGENERIC;
 
128
    }
 
129
    skip_space( &psz_command );
 
130
    if( isdigit( *psz_command ) )
 
131
    {
 
132
        if( parse_digit( &psz_command, &p_params->i_width ) == VLC_EGENERIC )
 
133
            return VLC_EGENERIC;
 
134
    }
 
135
    skip_space( &psz_command );
 
136
    if( isdigit( *psz_command ) )
 
137
    {
 
138
        if( parse_digit( &psz_command, &p_params->i_height ) == VLC_EGENERIC )
 
139
            return VLC_EGENERIC;
 
140
    }
 
141
    skip_space( &psz_command );
 
142
    if( isascii( *psz_command ) )
 
143
    {
 
144
        if( parse_char( &psz_command, &psz_end, 4, (char*)&p_params->fourcc )
 
145
            == VLC_EGENERIC )
 
146
            return VLC_EGENERIC;
 
147
    }
 
148
    skip_space( &psz_command );
 
149
    if( isdigit( *psz_command ) )
 
150
    {
 
151
        if( parse_digit( &psz_command, &p_params->i_shmid ) == VLC_EGENERIC )
 
152
            return VLC_EGENERIC;
 
153
    }
 
154
    return VLC_SUCCESS;
 
155
}
 
156
 
 
157
static int parser_Id( char *psz_command, char *psz_end,
 
158
                      commandparams_t *p_params )
 
159
{
 
160
    VLC_UNUSED(psz_end);
 
161
    skip_space( &psz_command );
 
162
    if( isdigit( *psz_command ) )
 
163
    {
 
164
        if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
 
165
            return VLC_EGENERIC;
 
166
    }
 
167
    return VLC_SUCCESS;
 
168
}
 
169
 
 
170
static int parser_None( char *psz_command, char *psz_end,
 
171
                        commandparams_t *p_params )
 
172
{
 
173
    VLC_UNUSED(psz_command);
 
174
    VLC_UNUSED(psz_end);
 
175
    VLC_UNUSED(p_params);
 
176
    return VLC_SUCCESS;
 
177
}
 
178
 
 
179
static int parser_SetAlpha( char *psz_command, char *psz_end,
 
180
                            commandparams_t *p_params )
 
181
{
 
182
    VLC_UNUSED(psz_end);
 
183
    skip_space( &psz_command );
 
184
    if( isdigit( *psz_command ) )
 
185
    {
 
186
        if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC  )
 
187
            return VLC_EGENERIC;
 
188
    }
 
189
    skip_space( &psz_command );
 
190
    if( isdigit( *psz_command ) )
 
191
    {
 
192
        if( parse_digit( &psz_command, &p_params->i_alpha ) == VLC_EGENERIC )
 
193
            return VLC_EGENERIC;
 
194
    }
 
195
    return VLC_SUCCESS;
 
196
}
 
197
 
 
198
static int parser_SetPosition( char *psz_command, char *psz_end,
 
199
                               commandparams_t *p_params )
 
200
{
 
201
    VLC_UNUSED(psz_end);
 
202
    skip_space( &psz_command );
 
203
    if( isdigit( *psz_command ) )
 
204
    {
 
205
        if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
 
206
            return VLC_EGENERIC;
 
207
    }
 
208
    skip_space( &psz_command );
 
209
    if( isdigit( *psz_command ) )
 
210
    {
 
211
        if( parse_digit( &psz_command, &p_params->i_x ) == VLC_EGENERIC )
 
212
            return VLC_EGENERIC;
 
213
    }
 
214
    skip_space( &psz_command );
 
215
    if( isdigit( *psz_command ) )
 
216
    {
 
217
        if( parse_digit( &psz_command, &p_params->i_y ) == VLC_EGENERIC )
 
218
            return VLC_EGENERIC;
 
219
    }
 
220
    return VLC_SUCCESS;
 
221
}
 
222
 
 
223
static int parser_SetTextAlpha( char *psz_command, char *psz_end,
 
224
                                commandparams_t *p_params )
 
225
{
 
226
    VLC_UNUSED(psz_end);
 
227
    skip_space( &psz_command );
 
228
    if( isdigit( *psz_command ) )
 
229
    {
 
230
        if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
 
231
            return VLC_EGENERIC;
 
232
    }
 
233
    skip_space( &psz_command );
 
234
    if( isdigit( *psz_command ) )
 
235
    {
 
236
        if( parse_digit( &psz_command, &p_params->fontstyle.i_font_alpha ) == VLC_EGENERIC )
 
237
            return VLC_EGENERIC;
 
238
    }
 
239
    return VLC_SUCCESS;
 
240
}
 
241
 
 
242
static int parser_SetTextColor( char *psz_command, char *psz_end,
 
243
                                commandparams_t *p_params )
 
244
{
 
245
    int r, g, b;
 
246
    VLC_UNUSED(psz_end);
 
247
    skip_space( &psz_command );
 
248
    if( isdigit( *psz_command ) )
 
249
    {
 
250
        if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
 
251
            return VLC_EGENERIC;
 
252
    }
 
253
    skip_space( &psz_command );
 
254
    if( isdigit( *psz_command ) )
 
255
    {
 
256
        if( parse_digit( &psz_command, &r ) == VLC_EGENERIC )
 
257
            return VLC_EGENERIC;
 
258
    }
 
259
    skip_space( &psz_command );
 
260
    if( isdigit( *psz_command ) )
 
261
    {
 
262
        if( parse_digit( &psz_command, &g ) == VLC_EGENERIC )
 
263
            return VLC_EGENERIC;
 
264
    }
 
265
    skip_space( &psz_command );
 
266
    if( isdigit( *psz_command ) )
 
267
    {
 
268
        if( parse_digit( &psz_command, &b ) == VLC_EGENERIC )
 
269
            return VLC_EGENERIC;
 
270
    }
 
271
    p_params->fontstyle.i_font_color = (r<<24) | (g<<16) | (b<<8);
 
272
    return VLC_SUCCESS;
 
273
}
 
274
 
 
275
static int parser_SetTextSize( char *psz_command, char *psz_end,
 
276
                               commandparams_t *p_params )
 
277
{
 
278
    VLC_UNUSED(psz_end);
 
279
    skip_space( &psz_command );
 
280
    if( isdigit( *psz_command ) )
 
281
    {
 
282
        if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
 
283
            return VLC_EGENERIC;
 
284
    }
 
285
    skip_space( &psz_command );
 
286
    if( isdigit( *psz_command ) )
 
287
    {
 
288
        if( parse_digit( &psz_command, &p_params->fontstyle.i_font_size ) == VLC_EGENERIC )
 
289
            return VLC_EGENERIC;
 
290
    }
 
291
    return VLC_SUCCESS;
 
292
}
 
293
 
 
294
static int parser_SetVisibility( char *psz_command, char *psz_end,
 
295
                                 commandparams_t *p_params )
 
296
{
 
297
    VLC_UNUSED(psz_end);
 
298
    skip_space( &psz_command );
 
299
    if( isdigit( *psz_command ) )
 
300
    {
 
301
        if( parse_digit( &psz_command, &p_params->i_id ) == VLC_EGENERIC )
 
302
            return VLC_EGENERIC;
 
303
    }
 
304
    skip_space( &psz_command );
 
305
    if( isdigit( *psz_command ) )
 
306
    {
 
307
        int32_t i_vis = 0;
 
308
        if( parse_digit( &psz_command, &i_vis ) == VLC_EGENERIC )
 
309
            return VLC_EGENERIC;
 
310
        p_params->b_visible = (i_vis == 1) ? true : false;
 
311
    }
 
312
    return VLC_SUCCESS;
 
313
}
 
314
 
 
315
/*****************************************************************************
 
316
 * Command unparser functions
 
317
 *****************************************************************************/
 
318
 
 
319
static int unparse_default( const commandparams_t *p_results,
 
320
                            buffer_t *p_output )
 
321
{
 
322
    VLC_UNUSED(p_results);
 
323
    VLC_UNUSED(p_output);
 
324
    return VLC_SUCCESS;
 
325
}
 
326
 
 
327
static int unparse_GenImage( const commandparams_t *p_results,
 
328
                             buffer_t *p_output )
 
329
{
 
330
    int ret = BufferPrintf( p_output, " %d", p_results->i_id );
 
331
    if( ret != VLC_SUCCESS )
 
332
        return ret;
 
333
 
 
334
    return VLC_SUCCESS;
 
335
}
 
336
 
 
337
static int unparse_GetAlpha( const commandparams_t *p_results,
 
338
                             buffer_t *p_output )
 
339
{
 
340
    int ret = BufferPrintf( p_output, " %d", p_results->i_alpha );
 
341
    if( ret != VLC_SUCCESS )
 
342
        return ret;
 
343
 
 
344
    return VLC_SUCCESS;
 
345
}
 
346
 
 
347
static int unparse_GetPosition( const commandparams_t *p_results,
 
348
                                buffer_t *p_output )
 
349
{
 
350
    int ret = BufferPrintf( p_output, " %d", p_results->i_x );
 
351
    if( ret != VLC_SUCCESS )
 
352
        return ret;
 
353
 
 
354
    ret = BufferPrintf( p_output, " %d", p_results->i_y );
 
355
    if( ret != VLC_SUCCESS )
 
356
        return ret;
 
357
 
 
358
    return VLC_SUCCESS;
 
359
}
 
360
 
 
361
static int unparse_GetTextAlpha( const commandparams_t *p_results,
 
362
                                 buffer_t *p_output )
 
363
{
 
364
    int ret = BufferPrintf( p_output, " %d", p_results->fontstyle.i_font_alpha );
 
365
    if( ret != VLC_SUCCESS )
 
366
        return ret;
 
367
 
 
368
    return VLC_SUCCESS;
 
369
}
 
370
 
 
371
static int unparse_GetTextColor( const commandparams_t *p_results,
 
372
                                 buffer_t *p_output )
 
373
{
 
374
    int ret = BufferPrintf( p_output, " %d", (p_results->fontstyle.i_font_color & 0xff0000)>>24 );
 
375
    if( ret != VLC_SUCCESS )
 
376
        return ret;
 
377
 
 
378
    ret = BufferPrintf( p_output, " %d", (p_results->fontstyle.i_font_color & 0x00ff00)>>16 );
 
379
    if( ret != VLC_SUCCESS )
 
380
        return ret;
 
381
 
 
382
    ret = BufferPrintf( p_output, " %d", (p_results->fontstyle.i_font_color & 0x0000ff)>>8 );
 
383
    if( ret != VLC_SUCCESS )
 
384
        return ret;
 
385
 
 
386
    return VLC_SUCCESS;
 
387
}
 
388
 
 
389
static int unparse_GetTextSize( const commandparams_t *p_results,
 
390
                                buffer_t *p_output )
 
391
{
 
392
    int ret = BufferPrintf( p_output, " %d", p_results->fontstyle.i_font_size );
 
393
    if( ret != VLC_SUCCESS )
 
394
        return ret;
 
395
 
 
396
    return VLC_SUCCESS;
 
397
}
 
398
 
 
399
static int unparse_GetVisibility( const commandparams_t *p_results,
 
400
                             buffer_t *p_output )
 
401
{
 
402
    int ret = BufferPrintf( p_output, " %d", (p_results->b_visible ? 1 : 0) );
 
403
    if( ret != VLC_SUCCESS ) {
 
404
        return ret;
 
405
    }
 
406
    return VLC_SUCCESS;
 
407
}
 
408
 
 
409
/*****************************************************************************
 
410
 * Command functions
 
411
 *****************************************************************************/
 
412
static int exec_DataSharedMem( filter_t *p_filter,
 
413
                               const commandparams_t *p_params,
 
414
                               commandparams_t *p_results )
 
415
{
 
416
#if defined(HAVE_SYS_SHM_H)
 
417
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
418
    struct shmid_ds shminfo;
 
419
    overlay_t *p_ovl;
 
420
    size_t i_size;
 
421
 
 
422
    VLC_UNUSED(p_results);
 
423
 
 
424
    p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
425
    if( p_ovl == NULL )
 
426
    {
 
427
        msg_Err( p_filter, "Invalid overlay: %d", p_params->i_id );
 
428
        return VLC_EGENERIC;
 
429
    }
 
430
 
 
431
    if( shmctl( p_params->i_shmid, IPC_STAT, &shminfo ) == -1 )
 
432
    {
 
433
        msg_Err( p_filter, "Unable to access shared memory" );
 
434
        return VLC_EGENERIC;
 
435
    }
 
436
    i_size = shminfo.shm_segsz;
 
437
 
 
438
    if( p_params->fourcc == VLC_FOURCC('T','E','X','T') )
 
439
    {
 
440
        char *p_data;
 
441
 
 
442
        if( (p_params->i_height != 1) || (p_params->i_width < 1) )
 
443
        {
 
444
            msg_Err( p_filter,
 
445
                     "Invalid width and/or height. when specifing text height "
 
446
                     "must be 1 and width the number of bytes in the string, "
 
447
                     "including the null terminator" );
 
448
            return VLC_EGENERIC;
 
449
        }
 
450
 
 
451
        if( (size_t)p_params->i_width > i_size )
 
452
        {
 
453
            msg_Err( p_filter,
 
454
                     "Insufficient data in shared memory. need %d, got %zu",
 
455
                     p_params->i_width, i_size );
 
456
            return VLC_EGENERIC;
 
457
        }
 
458
 
 
459
        p_ovl->data.p_text = malloc( p_params->i_width );
 
460
        if( p_ovl->data.p_text == NULL )
 
461
        {
 
462
            msg_Err( p_filter, "Unable to allocate string storage" );
 
463
            return VLC_ENOMEM;
 
464
        }
 
465
 
 
466
        vout_InitFormat( &p_ovl->format, VLC_FOURCC('T','E','X','T'),
 
467
                         0, 0, 0 );
 
468
 
 
469
        p_data = shmat( p_params->i_shmid, NULL, SHM_RDONLY );
 
470
        if( p_data == NULL )
 
471
        {
 
472
            msg_Err( p_filter, "Unable to attach to shared memory" );
 
473
            free( p_ovl->data.p_text );
 
474
            p_ovl->data.p_text = NULL;
 
475
            return VLC_ENOMEM;
 
476
        }
 
477
        memcpy( p_ovl->data.p_text, p_data, p_params->i_width );
 
478
 
 
479
        shmdt( p_data );
 
480
    }
 
481
    else
 
482
    {
 
483
        uint8_t *p_data, *p_in;
 
484
        size_t i_neededsize = 0;
 
485
 
 
486
        p_ovl->data.p_pic = malloc( sizeof( picture_t ) );
 
487
        if( p_ovl->data.p_pic == NULL )
 
488
            return VLC_ENOMEM;
 
489
 
 
490
        vout_InitFormat( &p_ovl->format, p_params->fourcc,
 
491
                         p_params->i_width, p_params->i_height,
 
492
                         VOUT_ASPECT_FACTOR );
 
493
        if( vout_AllocatePicture( p_filter, p_ovl->data.p_pic,
 
494
                                  p_ovl->format.i_chroma, p_params->i_width,
 
495
                                  p_params->i_height, p_ovl->format.i_aspect ) )
 
496
        {
 
497
            msg_Err( p_filter, "Unable to allocate picture" );
 
498
            free( p_ovl->data.p_pic );
 
499
            p_ovl->data.p_pic = NULL;
 
500
            return VLC_ENOMEM;
 
501
        }
 
502
 
 
503
        for( size_t i_plane = 0; i_plane < (size_t)p_ovl->data.p_pic->i_planes;
 
504
             ++i_plane )
 
505
        {
 
506
            i_neededsize += p_ovl->data.p_pic->p[i_plane].i_visible_lines *
 
507
                            p_ovl->data.p_pic->p[i_plane].i_visible_pitch;
 
508
        }
 
509
 
 
510
        if( i_neededsize > i_size )
 
511
        {
 
512
            msg_Err( p_filter,
 
513
                     "Insufficient data in shared memory. need %zu, got %zu",
 
514
                     i_neededsize, i_size );
 
515
            picture_Release( p_ovl->data.p_pic );
 
516
            free( p_ovl->data.p_pic );
 
517
            p_ovl->data.p_pic = NULL;
 
518
            return VLC_EGENERIC;
 
519
        }
 
520
 
 
521
        p_data = shmat( p_params->i_shmid, NULL, SHM_RDONLY );
 
522
        if( p_data == NULL )
 
523
        {
 
524
            msg_Err( p_filter, "Unable to attach to shared memory" );
 
525
            picture_Release( p_ovl->data.p_pic );
 
526
            free( p_ovl->data.p_pic );
 
527
            p_ovl->data.p_pic = NULL;
 
528
            return VLC_ENOMEM;
 
529
        }
 
530
 
 
531
        p_in = p_data;
 
532
        for( size_t i_plane = 0; i_plane < (size_t)p_ovl->data.p_pic->i_planes;
 
533
             ++i_plane )
 
534
        {
 
535
            uint8_t *p_out = p_ovl->data.p_pic->p[i_plane].p_pixels;
 
536
            for( size_t i_line = 0;
 
537
                 i_line < (size_t)p_ovl->data.p_pic->p[i_plane].i_visible_lines;
 
538
                 ++i_line )
 
539
            {
 
540
                vlc_memcpy( p_out, p_in,
 
541
                            p_ovl->data.p_pic->p[i_plane].i_visible_pitch );
 
542
                p_out += p_ovl->data.p_pic->p[i_plane].i_pitch;
 
543
                p_in += p_ovl->data.p_pic->p[i_plane].i_visible_pitch;
 
544
            }
 
545
        }
 
546
        shmdt( p_data );
 
547
    }
 
548
    p_sys->b_updated = p_ovl->b_active;
 
549
 
 
550
    return VLC_SUCCESS;
 
551
#else
 
552
    VLC_UNUSED(p_params);
 
553
    VLC_UNUSED(p_results);
 
554
 
 
555
    msg_Err( p_filter, "system doesn't support shared memory" );
 
556
    return VLC_EGENERIC;
 
557
#endif
 
558
}
 
559
 
 
560
static int exec_DeleteImage( filter_t *p_filter,
 
561
                             const commandparams_t *p_params,
 
562
                             commandparams_t *p_results )
 
563
{
 
564
    VLC_UNUSED(p_results);
 
565
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
566
    p_sys->b_updated = true;
 
567
 
 
568
    return ListRemove( &p_sys->overlays, p_params->i_id );
 
569
}
 
570
 
 
571
static int exec_EndAtomic( filter_t *p_filter,
 
572
                           const commandparams_t *p_params,
 
573
                           commandparams_t *p_results )
 
574
{
 
575
    VLC_UNUSED(p_params);
 
576
    VLC_UNUSED(p_results);
 
577
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
578
    QueueTransfer( &p_sys->pending, &p_sys->atomic );
 
579
    p_sys->b_atomic = false;
 
580
    return VLC_SUCCESS;
 
581
}
 
582
 
 
583
static int exec_GenImage( filter_t *p_filter,
 
584
                          const commandparams_t *p_params,
 
585
                          commandparams_t *p_results )
 
586
{
 
587
    VLC_UNUSED(p_params);
 
588
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
589
 
 
590
    overlay_t *p_ovl = OverlayCreate();
 
591
    if( p_ovl == NULL )
 
592
        return VLC_ENOMEM;
 
593
 
 
594
    ssize_t i_idx = ListAdd( &p_sys->overlays, p_ovl );
 
595
    if( i_idx < 0 )
 
596
        return i_idx;
 
597
 
 
598
    p_results->i_id = i_idx;
 
599
    return VLC_SUCCESS;
 
600
}
 
601
 
 
602
static int exec_GetAlpha( filter_t *p_filter,
 
603
                          const commandparams_t *p_params,
 
604
                          commandparams_t *p_results )
 
605
{
 
606
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
607
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
608
    if( p_ovl == NULL )
 
609
        return VLC_EGENERIC;
 
610
 
 
611
    p_results->i_alpha = p_ovl->i_alpha;
 
612
    return VLC_SUCCESS;
 
613
}
 
614
 
 
615
static int exec_GetPosition( filter_t *p_filter,
 
616
                             const commandparams_t *p_params,
 
617
                             commandparams_t *p_results )
 
618
{
 
619
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
620
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
621
    if( p_ovl == NULL )
 
622
        return VLC_EGENERIC;
 
623
 
 
624
    p_results->i_x = p_ovl->i_x;
 
625
    p_results->i_y = p_ovl->i_y;
 
626
    return VLC_SUCCESS;
 
627
}
 
628
 
 
629
static int exec_GetTextAlpha( filter_t *p_filter,
 
630
                              const commandparams_t *p_params,
 
631
                              commandparams_t *p_results )
 
632
{
 
633
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
634
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
635
    if( p_ovl == NULL )
 
636
        return VLC_EGENERIC;
 
637
 
 
638
    p_results->fontstyle.i_font_alpha = p_ovl->fontstyle.i_font_alpha;
 
639
    return VLC_SUCCESS;
 
640
}
 
641
 
 
642
static int exec_GetTextColor( filter_t *p_filter,
 
643
                              const commandparams_t *p_params,
 
644
                              commandparams_t *p_results )
 
645
{
 
646
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
647
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
648
    if( p_ovl == NULL )
 
649
        return VLC_EGENERIC;
 
650
 
 
651
    p_results->fontstyle.i_font_color = p_ovl->fontstyle.i_font_color;
 
652
    return VLC_SUCCESS;
 
653
}
 
654
 
 
655
static int exec_GetTextSize( filter_t *p_filter,
 
656
                             const commandparams_t *p_params,
 
657
                             commandparams_t *p_results )
 
658
{
 
659
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
660
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
661
    if( p_ovl == NULL )
 
662
        return VLC_EGENERIC;
 
663
 
 
664
    p_results->fontstyle.i_font_size = p_ovl->fontstyle.i_font_size;
 
665
    return VLC_SUCCESS;
 
666
}
 
667
 
 
668
static int exec_GetVisibility( filter_t *p_filter,
 
669
                               const commandparams_t *p_params,
 
670
                               commandparams_t *p_results )
 
671
{
 
672
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
673
 
 
674
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
675
    if( p_ovl == NULL )
 
676
        return VLC_EGENERIC;
 
677
 
 
678
    p_results->b_visible = ( p_ovl->b_active == true ) ? 1 : 0;
 
679
    return VLC_SUCCESS;
 
680
}
 
681
 
 
682
static int exec_SetAlpha( filter_t *p_filter,
 
683
                          const commandparams_t *p_params,
 
684
                          commandparams_t *p_results )
 
685
{
 
686
    VLC_UNUSED(p_results);
 
687
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
688
 
 
689
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
690
    if( p_ovl == NULL )
 
691
        return VLC_EGENERIC;
 
692
 
 
693
    p_ovl->i_alpha = p_params->i_alpha;
 
694
    p_sys->b_updated = p_ovl->b_active;
 
695
    return VLC_SUCCESS;
 
696
}
 
697
 
 
698
static int exec_SetPosition( filter_t *p_filter,
 
699
                             const commandparams_t *p_params,
 
700
                             commandparams_t *p_results )
 
701
{
 
702
    VLC_UNUSED(p_results);
 
703
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
704
 
 
705
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
706
    if( p_ovl == NULL )
 
707
        return VLC_EGENERIC;
 
708
 
 
709
    p_ovl->i_x = p_params->i_x;
 
710
    p_ovl->i_y = p_params->i_y;
 
711
 
 
712
    p_sys->b_updated = p_ovl->b_active;
 
713
    return VLC_SUCCESS;
 
714
}
 
715
 
 
716
static int exec_SetTextAlpha( filter_t *p_filter,
 
717
                              const commandparams_t *p_params,
 
718
                              commandparams_t *p_results )
 
719
{
 
720
    VLC_UNUSED(p_results);
 
721
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
722
 
 
723
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
724
    if( p_ovl == NULL )
 
725
        return VLC_EGENERIC;
 
726
 
 
727
    p_ovl->fontstyle.i_font_alpha = p_params->fontstyle.i_font_alpha;
 
728
    p_sys->b_updated = p_ovl->b_active;
 
729
    return VLC_SUCCESS;
 
730
}
 
731
 
 
732
static int exec_SetTextColor( filter_t *p_filter,
 
733
                              const commandparams_t *p_params,
 
734
                              commandparams_t *p_results )
 
735
{
 
736
    VLC_UNUSED(p_results);
 
737
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
738
 
 
739
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
740
    if( p_ovl == NULL )
 
741
        return VLC_EGENERIC;
 
742
 
 
743
    p_ovl->fontstyle.i_font_color = p_params->fontstyle.i_font_color;
 
744
    p_sys->b_updated = p_ovl->b_active;
 
745
    return VLC_SUCCESS;
 
746
}
 
747
 
 
748
static int exec_SetTextSize( filter_t *p_filter,
 
749
                              const commandparams_t *p_params,
 
750
                              commandparams_t *p_results )
 
751
{
 
752
    VLC_UNUSED(p_results);
 
753
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
754
 
 
755
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
756
    if( p_ovl == NULL )
 
757
        return VLC_EGENERIC;
 
758
 
 
759
    p_ovl->fontstyle.i_font_size = p_params->fontstyle.i_font_size;
 
760
    p_sys->b_updated = p_ovl->b_active;
 
761
    return VLC_SUCCESS;
 
762
}
 
763
 
 
764
static int exec_SetVisibility( filter_t *p_filter,
 
765
                               const commandparams_t *p_params,
 
766
                               commandparams_t *p_results )
 
767
{
 
768
    VLC_UNUSED(p_results);
 
769
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
770
 
 
771
    overlay_t *p_ovl = ListGet( &p_sys->overlays, p_params->i_id );
 
772
    if( p_ovl == NULL )
 
773
        return VLC_EGENERIC;
 
774
 
 
775
    p_ovl->b_active = p_params->b_visible;// ? false : true;
 
776
    p_sys->b_updated = true;
 
777
    return VLC_SUCCESS;
 
778
}
 
779
 
 
780
static int exec_StartAtomic( filter_t *p_filter,
 
781
                             const commandparams_t *p_params,
 
782
                             commandparams_t *p_results )
 
783
{
 
784
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
785
    VLC_UNUSED(p_params);
 
786
    VLC_UNUSED(p_results);
 
787
 
 
788
    p_sys->b_atomic = true;
 
789
    return VLC_SUCCESS;
 
790
}
 
791
 
 
792
/*****************************************************************************
 
793
 * Command functions
 
794
 *****************************************************************************/
 
795
static const commanddesc_t p_commands[] =
 
796
{
 
797
    {   .psz_command = "DataSharedMem",
 
798
        .b_atomic = true,
 
799
        .pf_parser = parser_DataSharedMem,
 
800
        .pf_execute = exec_DataSharedMem,
 
801
        .pf_unparse = unparse_default,
 
802
    },
 
803
    {   .psz_command = "DeleteImage",
 
804
        .b_atomic = true,
 
805
        .pf_parser = parser_Id,
 
806
        .pf_execute = exec_DeleteImage,
 
807
        .pf_unparse = unparse_default,
 
808
    },
 
809
    {   .psz_command = "EndAtomic",
 
810
        .b_atomic = false,
 
811
        .pf_parser = parser_None,
 
812
        .pf_execute = exec_EndAtomic,
 
813
        .pf_unparse = unparse_default,
 
814
    },
 
815
    {   .psz_command = "GenImage",
 
816
        .b_atomic = false,
 
817
        .pf_parser = parser_None,
 
818
        .pf_execute = exec_GenImage,
 
819
        .pf_unparse = unparse_GenImage,
 
820
    },
 
821
    {   .psz_command = "GetAlpha",
 
822
        .b_atomic = false,
 
823
        .pf_parser = parser_Id,
 
824
        .pf_execute = exec_GetAlpha,
 
825
        .pf_unparse = unparse_GetAlpha,
 
826
    },
 
827
    {   .psz_command = "GetPosition",
 
828
        .b_atomic = false,
 
829
        .pf_parser = parser_Id,
 
830
        .pf_execute = exec_GetPosition,
 
831
        .pf_unparse = unparse_GetPosition,
 
832
    },
 
833
    {   .psz_command = "GetTextAlpha",
 
834
        .b_atomic = false,
 
835
        .pf_parser = parser_Id,
 
836
        .pf_execute = exec_GetTextAlpha,
 
837
        .pf_unparse = unparse_GetTextAlpha,
 
838
    },
 
839
    {   .psz_command = "GetTextColor",
 
840
        .b_atomic = false,
 
841
        .pf_parser = parser_Id,
 
842
        .pf_execute = exec_GetTextColor,
 
843
        .pf_unparse = unparse_GetTextColor,
 
844
    },
 
845
    {   .psz_command = "GetTextSize",
 
846
        .b_atomic = true,
 
847
        .pf_parser = parser_Id,
 
848
        .pf_execute = exec_GetTextSize,
 
849
        .pf_unparse = unparse_GetTextSize,
 
850
    },
 
851
    {   .psz_command = "GetVisibility",
 
852
        .b_atomic = false,
 
853
        .pf_parser = parser_Id,
 
854
        .pf_execute = exec_GetVisibility,
 
855
        .pf_unparse = unparse_GetVisibility,
 
856
    },
 
857
    {   .psz_command = "SetAlpha",
 
858
        .b_atomic = true,
 
859
        .pf_parser = parser_SetAlpha,
 
860
        .pf_execute = exec_SetAlpha,
 
861
        .pf_unparse = unparse_default,
 
862
    },
 
863
    {   .psz_command = "SetPosition",
 
864
        .b_atomic = true,
 
865
        .pf_parser = parser_SetPosition,
 
866
        .pf_execute = exec_SetPosition,
 
867
        .pf_unparse = unparse_default,
 
868
    },
 
869
    {   .psz_command = "SetTextAlpha",
 
870
        .b_atomic = true,
 
871
        .pf_parser = parser_SetTextAlpha,
 
872
        .pf_execute = exec_SetTextAlpha,
 
873
        .pf_unparse = unparse_default,
 
874
    },
 
875
    {   .psz_command = "SetTextColor",
 
876
        .b_atomic = true,
 
877
        .pf_parser = parser_SetTextColor,
 
878
        .pf_execute = exec_SetTextColor,
 
879
        .pf_unparse = unparse_default,
 
880
    },
 
881
    {   .psz_command = "SetTextSize",
 
882
        .b_atomic = true,
 
883
        .pf_parser = parser_SetTextSize,
 
884
        .pf_execute = exec_SetTextSize,
 
885
        .pf_unparse = unparse_default,
 
886
    },
 
887
    {   .psz_command = "SetVisibility",
 
888
        .b_atomic = true,
 
889
        .pf_parser = parser_SetVisibility,
 
890
        .pf_execute = exec_SetVisibility,
 
891
        .pf_unparse = unparse_default,
 
892
    },
 
893
    {   .psz_command = "StartAtomic",
 
894
        .b_atomic = true,
 
895
        .pf_parser = parser_None,
 
896
        .pf_execute = exec_StartAtomic,
 
897
        .pf_unparse = unparse_default,
 
898
    }
 
899
};
 
900
 
 
901
void RegisterCommand( filter_t *p_filter )
 
902
{
 
903
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
904
    size_t i_index = 0;
 
905
 
 
906
    p_sys->i_commands = ARRAY_SIZE(p_commands);
 
907
    p_sys->pp_commands = (commanddesc_t **) calloc( p_sys->i_commands, sizeof(commanddesc_t*) );
 
908
    if( !p_sys->pp_commands ) return;
 
909
    for( i_index = 0; i_index < p_sys->i_commands; i_index ++ )
 
910
    {
 
911
        p_sys->pp_commands[i_index] = (commanddesc_t *) malloc( sizeof(commanddesc_t) );
 
912
        if( !p_sys->pp_commands[i_index] ) return;
 
913
        p_sys->pp_commands[i_index]->psz_command = strdup( p_commands[i_index].psz_command );
 
914
        p_sys->pp_commands[i_index]->b_atomic = p_commands[i_index].b_atomic;
 
915
        p_sys->pp_commands[i_index]->pf_parser = p_commands[i_index].pf_parser;
 
916
        p_sys->pp_commands[i_index]->pf_execute = p_commands[i_index].pf_execute;
 
917
        p_sys->pp_commands[i_index]->pf_unparse = p_commands[i_index].pf_unparse;
 
918
    }
 
919
 
 
920
    msg_Dbg( p_filter, "%zu commands are available", p_sys->i_commands );
 
921
    for( size_t i_index = 0; i_index < p_sys->i_commands; i_index++ )
 
922
        msg_Dbg( p_filter, "    %s", p_sys->pp_commands[i_index]->psz_command );
 
923
}
 
924
 
 
925
void UnregisterCommand( filter_t *p_filter )
 
926
{
 
927
    filter_sys_t *p_sys = (filter_sys_t*) p_filter->p_sys;
 
928
    size_t i_index = 0;
 
929
 
 
930
    for( i_index = 0; i_index < p_sys->i_commands; i_index++ )
 
931
    {
 
932
        free( p_sys->pp_commands[i_index]->psz_command );
 
933
        free( p_sys->pp_commands[i_index] );
 
934
    }
 
935
    free( p_sys->pp_commands );
 
936
    p_sys->pp_commands = NULL;
 
937
    p_sys->i_commands = 0;
 
938
}