Merge branch 'dynamicoverlay'

THANKS

@@ -208,6 +208,7 @@ Sebastian Jenny <jenny - sebastian &t gmail - com > - AAC decoding channel order
 Sebastien Chaumat <Sebastien.Chaumat at ens-lyon.fr> - YOPY port tests
 Sidney Doria <ssdoria qt gmail.com> - Brazilian Portuguese localisation
 Simon Damkjær Andersen <simondamkjaer at gmail.com> - playmode icons and the entire Fullscreen Panel design for the OSX GUI (v0.8.6)
+Soren Bog <avacore at videolan dot org> - dynamicoverlays
 Stefán Freyr Stefánsson <stefan.freyr -at- gmail.com> - Qt4 speed slider
 Steve Lhomme <steve dot lhomme at free dot fr> - MSVC fixes and Matroska enhancements
 Steve Brown <sbrown at cortland.com> - fix for optional PES size bug

configure.ac

@@ -1200,7 +1200,7 @@ dnl
 VLC_ADD_PLUGINS([dummy logger memcpy])
 VLC_ADD_PLUGINS([mpgv mpga m4v m4a h264 vc1 demux_cdg cdg ps pva avi asf mp4 rawdv rawvid nsv real aiff mjpeg demuxdump flacsys tta])
 VLC_ADD_PLUGINS([cvdsub svcdsub spudec subsdec subsusf t140 dvbsub cc mpeg_audio lpcm a52 dts cinepak flac])
-VLC_ADD_PLUGINS([deinterlace invert adjust transform wave ripple psychedelic gradient motionblur rv32 rotate noise grain extract sharpen seamcarving croppadd])
+VLC_ADD_PLUGINS([deinterlace invert adjust transform wave ripple psychedelic gradient motionblur rv32 rotate noise grain extract sharpen seamcarving croppadd dynamicoverlay blendbench])
 VLC_ADD_PLUGINS([converter_fixed mono])
 VLC_ADD_PLUGINS([trivial_resampler ugly_resampler])
 VLC_ADD_PLUGINS([trivial_channel_mixer trivial_mixer])
@@ -6294,6 +6294,7 @@ AC_CONFIG_FILES([
   modules/video_chroma/Makefile
   modules/video_filter/Makefile
   modules/video_filter/atmo/Makefile
+  modules/video_filter/dynamicoverlay/Makefile
   modules/video_output/Makefile
   modules/video_output/msw/Makefile
   modules/video_output/qte/Makefile

include/vlc_vout.h

@@ -211,10 +211,11 @@ struct subpicture_region_t
     int             i_x;                             /**< position of region */
     int             i_y;                             /**< position of region */
     int             i_align;                  /**< alignment within a region */
+    int             i_alpha;                               /**< transparency */
 
     char            *psz_text;       /**< text string comprising this region */
     char            *psz_html;       /**< HTML version of subtitle (NULL = use psz_text) */
-    text_style_t    *p_style;  /* a description of the text style formatting */
+    text_style_t    *p_style;        /**< a description of the text style formatting */
 
     subpicture_region_t *p_next;                /**< next region in the list */
     subpicture_region_t *p_cache;       /**< modified version of this region */

modules/video_filter/Modules.am

@@ -36,4 +36,5 @@ SOURCES_gaussianblur = gaussianblur.c
 SOURCES_grain = grain.c
 SOURCES_seamcarving = seamcarving.c
 SOURCES_croppadd = croppadd.c
+SOURCES_blendbench = blendbench.c
 noinst_HEADERS = filter_common.h filter_picture.h

modules/video_filter/blendbench.c

+/*****************************************************************************
+ * blendbench.c : blending benchmark plugin for vlc
+ *****************************************************************************
+ * Copyright (C) 2007 the VideoLAN team
+ * $Id$
+ *
+ * Author: Søren Bøg <avacore@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc/vlc.h>
+#include <vlc_sout.h>
+#include <vlc_vout.h>
+
+#include "vlc_filter.h"
+#include "vlc_image.h"
+
+/*****************************************************************************
+ * Local prototypes
+ *****************************************************************************/
+static int Create( vlc_object_t * );
+static void Destroy( vlc_object_t * );
+
+static picture_t *Filter( filter_t *, picture_t * );
+
+/*****************************************************************************
+ * Module descriptor
+ *****************************************************************************/
+
+#define LOOPS_TEXT N_("Number of time to blend")
+#define LOOPS_LONGTEXT N_("The number of time the blend will be performed")
+
+#define ALPHA_TEXT N_("Alpha of the blended image")
+#define ALPHA_LONGTEXT N_("Alpha with which the blend image is blended")
+
+#define BASE_IMAGE_TEXT N_("Image to be blended onto")
+#define BASE_IMAGE_LONGTEXT N_("The image which will be used to blend onto")
+
+#define BASE_CHROMA_TEXT N_("Chroma for the base image")
+#define BASE_CHROMA_LONGTEXT N_("Chroma which the base image will be loaded in")
+
+#define BLEND_IMAGE_TEXT N_("Image which will be blended.")
+#define BLEND_IMAGE_LONGTEXT N_("The image blended onto the base image")
+
+#define BLEND_CHROMA_TEXT N_("Chroma for the blend image")
+#define BLEND_CHROMA_LONGTEXT N_("Chroma which the blend image will be loaded" \
+                                 "in")
+
+#define CFG_PREFIX "blendbench-"
+
+vlc_module_begin();
+    set_description( _("Blending benchmark filter") );
+    set_shortname( _("blendbench" ));
+    set_category( CAT_VIDEO );
+    set_subcategory( SUBCAT_VIDEO_VFILTER );
+    set_capability( "video filter2", 0 );
+
+    set_section( N_("Benchmarking"), NULL );
+    add_integer( CFG_PREFIX "loops", 1000, NULL, LOOPS_TEXT,
+              LOOPS_LONGTEXT, VLC_FALSE );
+    add_integer_with_range( CFG_PREFIX "alpha", 128, 0, 255, NULL, ALPHA_TEXT,
+              ALPHA_LONGTEXT, VLC_FALSE );
+
+    set_section( N_("Base image"), NULL );
+    add_file( CFG_PREFIX "base-image", NULL, NULL, BASE_IMAGE_TEXT,
+              BASE_IMAGE_LONGTEXT, VLC_FALSE );
+    add_string( CFG_PREFIX "base-chroma", "I420", NULL, BASE_CHROMA_TEXT,
+              BASE_CHROMA_LONGTEXT, VLC_FALSE );
+
+    set_section( N_("Blend image"), NULL );
+    add_file( CFG_PREFIX "blend-image", NULL, NULL, BLEND_IMAGE_TEXT,
+              BLEND_IMAGE_LONGTEXT, VLC_FALSE );
+    add_string( CFG_PREFIX "blend-chroma", "YUVA", NULL, BLEND_CHROMA_TEXT,
+              BLEND_CHROMA_LONGTEXT, VLC_FALSE );
+
+    set_callbacks( Create, Destroy );
+vlc_module_end();
+
+static const char *ppsz_filter_options[] = {
+    "loops", "alpha", "base-image", "base-chroma", "blend-image",
+    "blend-chroma", NULL
+};
+
+/*****************************************************************************
+ * filter_sys_t: filter method descriptor
+ *****************************************************************************/
+struct filter_sys_t
+{
+    vlc_bool_t b_done;
+    int i_loops, i_alpha;
+
+    picture_t *p_base_image;
+    picture_t *p_blend_image;
+
+    vlc_fourcc_t i_base_chroma;
+    vlc_fourcc_t i_blend_chroma;
+};
+
+static int LoadImage( vlc_object_t *p_this, picture_t **pp_pic,
+                       vlc_fourcc_t i_chroma, char *psz_file, const char *psz_name )
+{
+    image_handler_t *p_image;
+    video_format_t fmt_in, fmt_out;
+
+    memset( &fmt_in, 0, sizeof(video_format_t) );
+    memset( &fmt_out, 0, sizeof(video_format_t) );
+
+    fmt_out.i_chroma = i_chroma;
+    p_image = image_HandlerCreate( p_this );
+    *pp_pic = image_ReadUrl( p_image, psz_file, &fmt_in, &fmt_out );
+    image_HandlerDelete( p_image );
+
+    if( *pp_pic == NULL ) {
+        msg_Err( p_this, "Unable to load %s image", psz_name );
+        return VLC_EGENERIC;
+    }
+
+    msg_Dbg( p_this, "%s image has dim %d x %d (Y plane)", psz_name,
+             (*pp_pic)->p[Y_PLANE].i_visible_pitch,
+             (*pp_pic)->p[Y_PLANE].i_visible_lines );
+
+    return VLC_SUCCESS;
+}
+
+/*****************************************************************************
+ * Create: allocates video thread output method
+ *****************************************************************************/
+static int Create( vlc_object_t *p_this )
+{
+    filter_t *p_filter = (filter_t *)p_this;
+    filter_sys_t *p_sys;
+    char *psz_temp;
+
+    /* Allocate structure */
+    p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
+    if( p_filter->p_sys == NULL )
+    {
+        msg_Err( p_filter, "out of memory" );
+        return VLC_ENOMEM;
+    }
+    p_sys = p_filter->p_sys;
+    p_sys->b_done = VLC_FALSE;
+
+    p_filter->pf_video_filter = Filter;
+
+    /* needed to get options passed in transcode using the
+     * adjust{name=value} syntax */
+    config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
+                       p_filter->p_cfg );
+
+    p_sys->i_loops = var_CreateGetIntegerCommand( p_filter,
+                                                  CFG_PREFIX "loops" );
+    p_sys->i_alpha = var_CreateGetIntegerCommand( p_filter,
+                                                  CFG_PREFIX "alpha" );
+
+    psz_temp = var_CreateGetStringCommand( p_filter, CFG_PREFIX "base-chroma" );
+    p_sys->i_base_chroma = VLC_FOURCC( psz_temp[0], psz_temp[1],
+                                       psz_temp[2], psz_temp[3] );
+    LoadImage( p_this, &p_sys->p_base_image, p_sys->i_base_chroma,
+               var_CreateGetStringCommand( p_filter, CFG_PREFIX "base-image" ),
+               "Base" );
+
+    psz_temp = var_CreateGetStringCommand( p_filter,
+                                           CFG_PREFIX "blend-chroma" );
+    p_sys->i_blend_chroma = VLC_FOURCC( psz_temp[0], psz_temp[1],
+                                        psz_temp[2], psz_temp[3] );
+    LoadImage( p_this, &p_sys->p_blend_image, p_sys->i_blend_chroma,
+               var_CreateGetStringCommand( p_filter, CFG_PREFIX "blend-image" ),
+               "Blend" );
+
+    return VLC_SUCCESS;
+}
+
+/*****************************************************************************
+ * Destroy: destroy video thread output method
+ *****************************************************************************/
+static void Destroy( vlc_object_t *p_this )
+{
+    filter_t *p_filter = (filter_t *)p_this;
+    filter_sys_t *p_sys = p_filter->p_sys;
+
+    p_sys->p_base_image->pf_release( p_sys->p_base_image );
+    p_sys->p_blend_image->pf_release( p_sys->p_blend_image );
+}
+
+/*****************************************************************************
+ * Render: displays previously rendered output
+ *****************************************************************************/
+static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
+{
+    filter_sys_t *p_sys = p_filter->p_sys;
+
+    if( p_sys->b_done )
+    {
+        return p_pic;
+    }
+
+    filter_t *p_blend;
+
+    p_blend = vlc_object_create( p_filter, VLC_OBJECT_FILTER );
+    vlc_object_attach( p_blend, p_filter );
+    p_blend->fmt_out.video = p_sys->p_base_image->format;
+    p_blend->fmt_in.video = p_sys->p_blend_image->format;
+    p_blend->p_module = module_Need( p_blend, "video blending", 0, 0 );
+
+    mtime_t time = mdate();
+    for( int i_iter = 0; i_iter < p_sys->i_loops; ++i_iter )
+    {
+        p_blend->pf_video_blend( p_blend, p_sys->p_base_image,
+                                 p_sys->p_base_image, p_sys->p_blend_image, 0,
+                                 0, p_sys->i_alpha );
+    }
+    time = mdate() - time;
+
+    msg_Info( p_filter, "Blended %d images in %f sec.", p_sys->i_loops,
+              time / 1000000.0f );
+    msg_Info( p_filter, "Speed is: %f images/second, %f pixels/second",
+              (float) p_sys->i_loops / time * 1000000,
+              (float) p_sys->i_loops / time * 1000000 *
+                  p_sys->p_blend_image->p[Y_PLANE].i_visible_pitch *
+                  p_sys->p_blend_image->p[Y_PLANE].i_visible_lines );
+
+    module_Unneed( p_blend, p_blend->p_module );
+
+    vlc_object_detach( p_blend );
+    vlc_object_release( p_blend );
+
+    p_sys->b_done = VLC_TRUE;
+    return p_pic;
+}

modules/video_filter/dynamicoverlay/Modules.am

+SOURCES_dynamicoverlay = dynamicoverlay_buffer.c dynamicoverlay_queue.c dynamicoverlay_list.c dynamicoverlay_commands.c  dynamicoverlay.c
+noinst_HEADERS = dynamicoverlay.h

modules/video_filter/dynamicoverlay/dynamicoverlay.h

+/*****************************************************************************
+ * dynamicoverlay.h : dynamic overlay plugin for vlc
+ *****************************************************************************
+ * Copyright (C) 2008 the VideoLAN team
+ * $Id$
+ *
+ * Author: Jean-Paul Saman <jpsaman@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+#ifndef DYNAMIC_OVERLAY_H
+#define DYNAMIC_OVERLAY_H   1
+
+#include <vlc/vlc.h>
+#include <vlc_filter.h>
+
+/*****************************************************************************
+ * buffer_t: Command and response buffer
+ *****************************************************************************/
+
+typedef struct buffer_t
+{
+    size_t i_size;                         /**< Size of the allocated memory */
+    size_t i_length;                          /**< Length of the stored data */
+
+    char *p_memory;                       /**< Start of the allocated memory */
+    char *p_begin;                             /**< Start of the stored data */
+} buffer_t;
+
+int BufferInit( buffer_t *p_buffer );
+int BufferDestroy( buffer_t *p_buffer );
+int BufferAdd( buffer_t *p_buffer, const char *p_data, size_t i_len );
+int BufferPrintf( buffer_t *p_buffer, const char *p_fmt, ... );
+int BufferDel( buffer_t *p_buffer, int i_len );
+char *BufferGetToken( buffer_t *p_buffer );
+
+/*****************************************************************************
+ * Command structures
+ *****************************************************************************/
+
+/** struct commandparams_t - command params structure */
+typedef struct commandparams_t
+{
+    int32_t i_id;       /*< overlay id */
+    int32_t i_shmid;    /*< shared memory identifier */
+
+    vlc_fourcc_t fourcc;/*< chroma */
+
+    int32_t i_x;        /*< x position of overlay */
+    int32_t i_y;        /*< y position of overlay */
+    int32_t i_width;    /*< width of overlay */
+    int32_t i_height;   /*< height of overlay */
+
+    int32_t i_alpha;    /*< alpha value of overlay */
+
+    struct text_style_t fontstyle; /*< text style */
+
+    vlc_bool_t b_visible; /*< visibility flag of overlay */
+} commandparams_t;
+
+typedef struct commanddesc_t
+{
+    const char *psz_command;
+    vlc_bool_t b_atomic;
+    int ( *pf_parser ) ( char *psz_command, char *psz_end,
+                         commandparams_t *p_params );
+    int ( *pf_execute ) ( filter_t *p_filter, const commandparams_t *p_params,
+                          commandparams_t *p_results );
+    int ( *pf_unparse ) ( const commandparams_t *p_results,
+                          buffer_t *p_output );
+} commanddesc_t;
+
+typedef struct command_t
+{
+    struct commanddesc_t *p_command;
+    int i_status;
+    commandparams_t params;
+    commandparams_t results;
+    struct command_t *p_next;
+} command_t;
+
+void RegisterCommand( filter_t *p_filter );
+void UnregisterCommand( filter_t *p_filter );
+
+/*****************************************************************************
+ * queue_t: Command queue
+ *****************************************************************************/
+
+typedef struct queue_t
+{
+    command_t *p_head;                  /**< Head (first entry) of the queue */
+    command_t *p_tail;                   /**< Tail (last entry) of the queue */
+} queue_t;
+
+int QueueInit( queue_t *p_queue );
+int QueueDestroy( queue_t *p_queue );
+int QueueEnqueue( queue_t *p_queue, command_t *p_cmd );
+command_t *QueueDequeue( queue_t *p_queue );
+int QueueTransfer( queue_t *p_sink, queue_t *p_source );
+
+/*****************************************************************************
+ * overlay_t: Overlay descriptor
+ *****************************************************************************/
+
+typedef struct overlay_t
+{
+    int i_x, i_y;
+    int i_alpha;
+    vlc_bool_t b_active;
+
+    video_format_t format;
+    struct text_style_t fontstyle;
+    union {
+        picture_t *p_pic;
+        char *p_text;
+    } data;
+} overlay_t;
+
+overlay_t *OverlayCreate( void );
+int OverlayDestroy( overlay_t *p_ovl );
+
+/*****************************************************************************
+ * list_t: Command queue
+ *****************************************************************************/
+
+typedef struct list_t
+{
+    overlay_t **pp_head, **pp_tail;
+} list_t;
+
+int ListInit( list_t *p_list );
+int ListDestroy( list_t *p_list );
+ssize_t ListAdd( list_t *p_list, overlay_t *p_new );
+int ListRemove( list_t *p_list, size_t i_idx );
+overlay_t *ListGet( list_t *p_list, size_t i_idx );
+overlay_t *ListWalk( list_t *p_list );
+
+/*****************************************************************************
+ * filter_sys_t: adjust filter method descriptor
+ *****************************************************************************/
+
+struct filter_sys_t
+{
+    buffer_t input, output;
+
+    int i_inputfd, i_outputfd;
+    char *psz_inputfile, *psz_outputfile;
+
+    commanddesc_t **pp_commands; /* array of commands */
+    size_t i_commands;
+
+    vlc_bool_t b_updated, b_atomic;
+    queue_t atomic, pending, processed;
+    list_t overlays;
+};
+
+#endif

modules/video_filter/dynamicoverlay/dynamicoverlay_buffer.c

+/*****************************************************************************
+ * dynamicoverlay_buffer.h : dynamic overlay buffer
+ *****************************************************************************
+ * Copyright (C) 2008 the VideoLAN team
+ * $Id$
+ *
+ * Author: Søren Bøg <avacore@videolan.org>
+ *         Jean-Paul Saman <jpsaman@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc/vlc.h>
+#include <vlc_osd.h>
+#include <vlc_filter.h>
+
+#include <ctype.h>
+
+#include "dynamicoverlay.h"
+
+/*****************************************************************************
+ * buffer_t: Command and response buffer
+ *****************************************************************************/
+
+int BufferInit( buffer_t *p_buffer )
+{
+    memset( p_buffer, 0, sizeof( buffer_t ) );
+    p_buffer->p_memory = NULL;
+    p_buffer->p_begin = NULL;
+
+    return VLC_SUCCESS;
+}
+
+int BufferDestroy( buffer_t *p_buffer )
+{
+    if( p_buffer->p_memory != NULL )
+    {
+        free( p_buffer->p_memory );
+    }
+    p_buffer->p_memory = NULL;
+    p_buffer->p_begin = NULL;
+
+    return VLC_SUCCESS;
+}
+
+char *BufferGetToken( buffer_t *p_buffer )
+{
+    char *p_char = p_buffer->p_begin;
+
+    while( isspace( p_char[0] ) || p_char[0] == '\0' )
+    {
+        if( p_char <= (p_buffer->p_begin + p_buffer->i_length) )
+            p_char++;
+        else
+            return NULL;
+    }
+    return p_char;
+}
+
+int BufferAdd( buffer_t *p_buffer, const char *p_data, size_t i_len )
+{
+    if( ( p_buffer->i_size - p_buffer->i_length -
+          ( p_buffer->p_begin - p_buffer->p_memory ) ) < i_len )
+    {
+        /* We'll have to do some rearranging to fit the new data. */
+        if( ( p_buffer->i_size - p_buffer->i_length ) >= i_len )
+        {
+            /* We have room in the current buffer, just need to move it */
+            memmove( p_buffer->p_memory, p_buffer->p_begin,
+                     p_buffer->i_length );
+            p_buffer->p_begin = p_buffer->p_memory;
+        }
+        else
+        {
+            // We need a bigger buffer
+            size_t i_newsize = 1024;
+            while( i_newsize < p_buffer->i_length + i_len )
+                i_newsize *= 2;
+            /* TODO: Should I handle wrapping here? */
+
+            /* I'm not using realloc here, as I can avoid a memcpy/memmove in
+               some (most?) cases, and reset the start of the buffer. */
+            char *p_newdata = malloc( i_newsize );
+            if( p_newdata == NULL )
+                return VLC_ENOMEM;
+            if( p_buffer->p_begin != NULL )
+            {
+                memcpy( p_newdata, p_buffer->p_begin, p_buffer->i_length );
+                free( p_buffer->p_memory );
+            }
+            p_buffer->p_memory = p_buffer->p_begin = p_newdata;
+            p_buffer->i_size = i_newsize;
+        }
+    }
+
+    /* Add the new data to the end of the current */
+    memcpy( p_buffer->p_begin + p_buffer->i_length, p_data, i_len );
+    p_buffer->i_length += i_len;
+    return VLC_SUCCESS;
+}
+
+int BufferPrintf( buffer_t *p_buffer, const char *p_fmt, ... )
+{
+    int i_len;
+    int status;
+    char *psz_data;
+
+    va_list va_list1, va_list2;
+    va_start( va_list1, p_fmt );
+    va_copy( va_list2, va_list1 );
+
+    i_len = vsnprintf( NULL, 0, p_fmt, va_list1 );
+    if( i_len < 0 )
+        return VLC_EGENERIC;
+    va_end( va_list1 );
+
+    psz_data = malloc( i_len + 1 );
+    if( psz_data == NULL ) {
+        return VLC_ENOMEM;
+    }
+    if( vsnprintf( psz_data, i_len + 1, p_fmt, va_list2 ) != i_len )
+    {
+        return VLC_EGENERIC;
+    }
+    va_end( va_list2 );
+    status = BufferAdd( p_buffer, psz_data, i_len );
+    free( psz_data );
+    return status;
+}
+
+int BufferDel( buffer_t *p_buffer, int i_len )
+{
+    p_buffer->i_length -= i_len;
+    if( p_buffer->i_length == 0 )
+    {
+        /* No data, we can reset the buffer now. */
+        p_buffer->p_begin = p_buffer->p_memory;
+    }
+    else
+    {
+        p_buffer->p_begin += i_len;
+    }
+    return VLC_SUCCESS;
+}

modules/video_filter/dynamicoverlay/dynamicoverlay_list.c

+/*****************************************************************************
+ * dynamicoverlay_list.h : dynamic overlay list
+ *****************************************************************************
+ * Copyright (C) 2008 the VideoLAN team
+ * $Id$
+ *
+ * Author: Søren Bøg <avacore@videolan.org>
+ *         Jean-Paul Saman <jpsaman@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc/vlc.h>
+#include <vlc_osd.h>
+
+#include <fcntl.h>
+#include "dynamicoverlay.h"
+
+/*****************************************************************************
+ * list_t: Command queue
+ *****************************************************************************/
+
+int ListInit( list_t *p_list )
+{
+    p_list->pp_head = malloc( 16 * sizeof( overlay_t * ) );
+    if( p_list->pp_head == NULL )
+        return VLC_ENOMEM;
+
+    p_list->pp_tail = p_list->pp_head + 16;
+    memset( p_list->pp_head, 0, 16 * sizeof( overlay_t * ) );
+
+    return VLC_SUCCESS;
+}
+
+int ListDestroy( list_t *p_list )
+{
+    for( overlay_t **pp_cur = p_list->pp_head;
+         pp_cur < p_list->pp_tail;
+         ++pp_cur )
+    {
+        if( *pp_cur != NULL )
+        {
+            OverlayDestroy( *pp_cur );
+            free( *pp_cur );
+        }
+    }
+    free( p_list->pp_head );
+
+    return VLC_SUCCESS;
+}
+
+ssize_t ListAdd( list_t *p_list, overlay_t *p_new )
+{
+    /* Find an available slot */
+    for( overlay_t **pp_cur = p_list->pp_head;
+         pp_cur < p_list->pp_tail;
+         ++pp_cur )
+    {
+        if( *pp_cur == NULL )
+        {
+            *pp_cur = p_new;
+            return pp_cur - p_list->pp_head;
+        }
+    }
+
+    /* Have to expand */
+    size_t i_size = p_list->pp_tail - p_list->pp_head;
+    size_t i_newsize = i_size * 2;
+    p_list->pp_head = realloc( p_list->pp_head,
+                               i_newsize * sizeof( overlay_t * ) );
+    if( p_list->pp_head == NULL )
+        return VLC_ENOMEM;
+
+    p_list->pp_tail = p_list->pp_head + i_newsize;
+    memset( p_list->pp_head + i_size, 0, i_size * sizeof( overlay_t * ) );
+    p_list->pp_head[i_size] = p_new;
+    return i_size;
+}
+
+int ListRemove( list_t *p_list, size_t i_idx )
+{
+    int ret;
+
+    if( ( i_idx >= (size_t)( p_list->pp_tail - p_list->pp_head ) ) ||
+        ( p_list->pp_head[i_idx] == NULL ) )
+    {
+        return VLC_EGENERIC;
+    }
+
+    ret = OverlayDestroy( p_list->pp_head[i_idx] );
+    free( p_list->pp_head[i_idx] );
+    p_list->pp_head[i_idx] = NULL;
+
+    return ret;
+}
+
+overlay_t *ListGet( list_t *p_list, size_t i_idx )
+{
+    if( ( i_idx >= (size_t)( p_list->pp_tail - p_list->pp_head ) ) ||
+        ( p_list->pp_head[i_idx] == NULL ) )
+    {
+        return NULL;
+    }
+    return p_list->pp_head[i_idx];
+}
+
+overlay_t *ListWalk( list_t *p_list )
+{
+    static overlay_t **pp_cur = NULL;
+
+    if( pp_cur == NULL )
+        pp_cur = p_list->pp_head;
+    else
+        pp_cur = pp_cur + 1;
+
+    for( ; pp_cur < p_list->pp_tail; ++pp_cur )
+    {
+        if( ( *pp_cur != NULL ) &&
+            ( (*pp_cur)->b_active == VLC_TRUE )&&
+            ( (*pp_cur)->format.i_chroma != VLC_FOURCC( '\0','\0','\0','\0') ) )
+        {
+            return *pp_cur;
+        }
+    }
+    pp_cur = NULL;
+    return NULL;
+}

modules/video_filter/dynamicoverlay/dynamicoverlay_queue.c

+/*****************************************************************************
+ * dynamicoverlay_commands.c : dynamic overlay plugin commands
+ *****************************************************************************
+ * Copyright (C) 2008 the VideoLAN team
+ * $Id$
+ *
+ * Author: Søren Bøg <avacore@videolan.org>
+ *         Jean-Paul Saman <jpsaman@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc/vlc.h>
+#include <vlc_osd.h>
+
+#include "dynamicoverlay.h"
+
+/*****************************************************************************
+ * queue_t: Command queue
+ *****************************************************************************/
+
+int QueueInit( queue_t *p_queue )
+{
+    memset( p_queue, 0, sizeof( queue_t ) );
+    p_queue->p_head = NULL;
+    p_queue->p_tail = NULL;
+
+    return VLC_SUCCESS;
+}
+
+int QueueDestroy( queue_t *p_queue )
+{
+    command_t *p_cur = p_queue->p_head, *p_temp;
+    while( p_cur != NULL )
+    {
+        p_temp = p_cur;
+        p_cur = p_cur->p_next;
+        free( p_temp );
+    }
+    p_queue->p_head = NULL;
+    p_queue->p_tail = NULL;
+
+    return VLC_SUCCESS;
+}
+
+int QueueEnqueue( queue_t *p_queue, command_t *p_cmd )
+{
+    if( p_queue->p_tail != NULL )
+    {
+        p_queue->p_tail->p_next = p_cmd;
+    }
+    if( p_queue->p_head == NULL )
+    {
+        p_queue->p_head = p_cmd;
+    }
+    p_queue->p_tail = p_cmd;
+    p_cmd->p_next = NULL;
+
+    return VLC_SUCCESS;
+}
+
+command_t *QueueDequeue( queue_t *p_queue )
+{
+    if( p_queue->p_head == NULL )
+    {
+        return NULL;
+    }
+    else
+    {
+        command_t *p_ret = p_queue->p_head;
+        if( p_queue->p_head == p_queue->p_tail )
+        {
+            p_queue->p_head = p_queue->p_tail = NULL;
+        }
+        else
+        {
+            p_queue->p_head = p_queue->p_head->p_next;
+        }
+        return p_ret;
+    }
+}
+
+int QueueTransfer( queue_t *p_sink, queue_t *p_source )
+{
+    if( p_source->p_head == NULL ) {
+        return VLC_SUCCESS;
+    }
+
+    if( p_sink->p_head == NULL ) {
+        p_sink->p_head = p_source->p_head;
+        p_sink->p_tail = p_source->p_tail;
+    } else {
+        p_sink->p_tail->p_next = p_source->p_head;
+        p_sink->p_tail = p_source->p_tail;
+    }
+    p_source->p_head = p_source->p_tail = NULL;
+
+    return VLC_SUCCESS;
+}

modules/video_filter/osdmenu.c

@@ -435,6 +435,7 @@ static subpicture_region_t *create_picture_region( filter_t *p_filter, subpictur
     p_region->i_x = 0;
     p_region->i_y = 0;
     p_region->i_align = p_filter->p_sys->i_position;
+    p_region->i_alpha = p_filter->p_sys->i_alpha;
 #if 0
     msg_Dbg( p_filter, "SPU picture region position (%d,%d) (%d,%d) [%p]",
         p_region->i_x, p_region->i_y,

src/video_output/vout_subpictures.c

@@ -291,6 +291,7 @@ subpicture_region_t *__spu_CreateRegion( vlc_object_t *p_this,
     if( !p_region ) return NULL;
 
     memset( p_region, 0, sizeof(subpicture_region_t) );
+    p_region->i_alpha = 0xff;
     p_region->p_next = NULL;
     p_region->p_cache = NULL;
     p_region->fmt = *p_fmt;
@@ -336,6 +337,7 @@ subpicture_region_t *__spu_MakeRegion( vlc_object_t *p_this,
     (void)p_this;
     if( !p_region ) return NULL;
     memset( p_region, 0, sizeof(subpicture_region_t) );
+    p_region->i_alpha = 0xff;
     p_region->p_next = 0;
     p_region->p_cache = 0;
     p_region->fmt = *p_fmt;
@@ -901,6 +903,7 @@ void spu_RenderSubpictures( spu_t *p_spu, video_format_t *p_fmt,
                 p_region->p_cache->i_x = p_region->i_x * pi_scale_width[ i_scale_idx ] / 1000;
                 p_region->p_cache->i_y = p_region->i_y * pi_scale_height[ i_scale_idx ] / 1000;
                 p_region->p_cache->i_align = p_region->i_align;
+                p_region->p_cache->i_alpha = p_region->i_alpha;
 
                 p_pic = p_spu->p_scale->pf_video_filter(
                                  p_spu->p_scale, &p_region->p_cache->picture );
@@ -1060,7 +1063,7 @@ void spu_RenderSubpictures( spu_t *p_spu, video_format_t *p_fmt,
                 {
                     p_spu->p_blend->pf_video_blend( p_spu->p_blend, p_pic_dst,
                         p_pic_src, &p_region->picture, i_x_offset, i_y_offset,
-                        i_fade_alpha * p_subpic->i_alpha / 255 );
+                        i_fade_alpha * p_subpic->i_alpha * p_region->i_alpha / 65025 );
                 }
                 else
                 {

test/dynamicoverlay/Makefile

+all: overlay-test
+
+overlay-test: overlay-test.c
+	gcc -g2 --std=c99 -D_XOPEN_SOURCE=500 overlay-test.c -lm -o overlay-test