* Added Continuous Media Markup Language (CMML) codec

configure.ac

@@ -2346,6 +2346,16 @@ AX_ADD_LDFLAGS([subsdec],[${LIBICONV}])
 AX_ADD_CPPFLAGS([subsdec],[${INCICONV}])
 AX_ADD_PLUGINS([subsdec])
 
+dnl
+dnl  CMML plugin
+dnl
+AC_ARG_ENABLE(cmml,
+  [  --enable-cmml           CMML support (default enabled)])
+if test "${enable_cmml}" != "no"
+then
+  AX_ADD_PLUGINS([cmml])
+fi
+
 
 dnl
 dnl  Video Filters
@@ -3776,6 +3786,7 @@ AC_CONFIG_FILES([
   modules/audio_mixer/Makefile
   modules/audio_output/Makefile
   modules/codec/Makefile
+  modules/codec/cmml/Makefile
   modules/codec/ffmpeg/Makefile
   modules/codec/ffmpeg/postprocessing/Makefile
   modules/codec/ogt/Makefile

modules/LIST

 List of vlc plugins (221)
-$Id: LIST,v 1.19 2004/01/05 13:07:02 zorglub Exp $
+$Id$
 
  * a52: A/52 basic parser/packetizer
 
@@ -70,6 +70,8 @@ $Id: LIST,v 1.19 2004/01/05 13:07:02 zorglub Exp $
  * cinepak: Cinepack video decoder
 
  * clone: Clone video filter
+ 
+ * cmml: Continuous Media Markup Language annotations/hyperlinks decoder
 
  * corba: CORBA control module
 

modules/codec/cmml/Modules.am

+SOURCES_cmml = \
+	browser_open.c browser_open.h \
+	cmml.c \
+	history.c history.h \
+	intf.c \
+	xarray.c xarray.h \
+	xlist.c xlist.h \
+	xstrcat.h \
+	xtag.c xtag.h \
+	xurl.c xurl.h
+

modules/codec/cmml/browser_open.c

+/*****************************************************************************
+ * browser_open.c: platform-independent opening of a web browser
+ *****************************************************************************
+ * Copyright (C) 2004 Commonwealth Scientific and Industrial Research
+ *                    Organisation (CSIRO) Australia
+ * Copyright (C) 2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Authors: Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "xstrcat.h"
+
+int browser_Open( char *psz_url )
+{
+#ifdef SYS_DARWIN
+    char *psz_open_commandline;
+
+    psz_open_commandline = strdup( "open " );
+    xstrcat( psz_open_commandline, psz_url );
+        
+    return system( psz_open_commandline );
+#elif defined( WIN32 )
+    char *psz_open_commandline;
+
+    psz_open_commandline = strdup( "explorer " );
+    xstrcat( psz_open_commandline, psz_url );
+
+    return system( psz_open_commandline );
+#else
+    /* Assume we're on a UNIX of some sort */
+    char *psz_open_commandline;
+
+    /* Debian uses www-browser */
+    psz_open_commandline = strdup( "www-browser" );
+    xstrcat( psz_open_commandline, psz_url );
+
+    if( system( psz_open_commandline ) != 0 )
+    {
+        free( psz_open_commandline );
+
+        /* Try mozilla */
+        psz_open_commandline = strdup( "mozilla" );
+        xstrcat( psz_open_commandline, psz_url );
+        return system( psz_open_commandline );
+    }
+#endif
+}
+

modules/codec/cmml/browser_open.h

+/*****************************************************************************
+ * browser_open.h: platform-independent opening of a web browser
+ *****************************************************************************
+ * Copyright (C) 2004 Commonwealth Scientific and Industrial Research
+ *                    Organisation (CSIRO) Australia
+ * Copyright (C) 2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Authors: Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __BROWSER_OPEN_H__
+#define __BROWSER_OPEN_H__
+
+int browser_Open( char *psz_url );
+
+#endif /* __BROWSER_OPEN_H__ */
+

modules/codec/cmml/cmml.c

+/*****************************************************************************
+ * cmml.c : CMML annotations/metadata decoder
+ *****************************************************************************
+ * Copyright (C) 2003-2004 Commonwealth Scientific and Industrial Research
+ *                         Organisation (CSIRO) Australia
+ * Copyright (C) 2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Author: Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#include <vlc/vlc.h>
+#include <vlc/decoder.h>
+#include <vlc/intf.h>
+
+#include <osd.h>
+
+#include "charset.h"
+
+#include "xtag.h"
+
+#undef CMML_DEBUG
+
+/*****************************************************************************
+ * decoder_sys_t : decoder descriptor
+ *****************************************************************************/
+struct decoder_sys_t
+{
+    intf_thread_t *     p_intf;
+};
+
+/*****************************************************************************
+ * Local prototypes
+ *****************************************************************************/
+static int  OpenDecoder   ( vlc_object_t * );
+static void CloseDecoder  ( vlc_object_t * );
+
+static void DecodeBlock   ( decoder_t *, block_t ** );
+
+static void ParseText     ( decoder_t *, block_t * );
+
+/*****************************************************************************
+ * Exported prototypes
+ *****************************************************************************/
+int  E_(OpenIntf)  ( vlc_object_t * );
+void E_(CloseIntf) ( vlc_object_t * );
+
+/*****************************************************************************
+ * Module descriptor.
+ *****************************************************************************/
+vlc_module_begin();
+    set_description( _("CMML annotations decoder") );
+    set_capability( "decoder", 50 );
+    set_callbacks( OpenDecoder, CloseDecoder );
+    add_shortcut( "cmml" );
+
+    add_submodule();
+        set_capability( "interface", 0 );
+        set_callbacks( E_(OpenIntf), E_(CloseIntf) );
+vlc_module_end();
+
+/*****************************************************************************
+ * OpenDecoder: probe the decoder and return score
+ *****************************************************************************
+ * Tries to launch a decoder and return score so that the interface is able
+ * to chose.
+ *****************************************************************************/
+static int OpenDecoder( vlc_object_t *p_this )
+{
+    decoder_t *p_dec = (decoder_t*)p_this;
+    input_thread_t * p_input;
+    decoder_sys_t *p_sys;
+    vlc_value_t val;
+
+    if( p_dec->fmt_in.i_codec != VLC_FOURCC('c','m','m','l') )
+    {
+        return VLC_EGENERIC;
+    }
+
+    p_dec->pf_decode_sub = DecodeBlock;
+
+#ifdef CMML_DEBUG
+    msg_Dbg( p_dec, "I am at %p", p_dec );
+#endif
+
+    /* Allocate the memory needed to store the decoder's structure */
+    if( ( p_dec->p_sys = p_sys =
+          (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
+    {
+        msg_Err( p_dec, "out of memory" );
+        return VLC_EGENERIC;
+    }
+
+    /* Let other interested modules know that we're a CMML decoder
+     * We have to set this variable on the input thread, because there's
+     * typically more than one decoder running so we can't find the CMML
+     * decoder succesfully with vlc_object_find.  (Any hints on how to achieve
+     * this would be rather appreciated ;) */
+    p_input = vlc_object_find( p_dec, VLC_OBJECT_INPUT, FIND_ANYWHERE );
+#ifdef CMML_DEBUG
+    msg_Dbg( p_dec, "p_input is at %p", p_input );
+#endif
+    val.p_address = p_dec;
+    var_Create( p_input, "has-cmml-decoder",
+                VLC_VAR_ADDRESS|VLC_VAR_DOINHERIT );
+    if( var_Set( p_input, "has-cmml-decoder", val ) != VLC_SUCCESS )
+    {
+        msg_Dbg( p_dec, "var_Set of has-cmml-decoder failed" );
+    }
+    vlc_object_release( p_input );
+
+    /* initialise the CMML responder interface */
+    p_sys->p_intf = intf_Create( p_dec, "cmml" );
+    p_sys->p_intf->b_block = VLC_FALSE;
+    intf_RunThread( p_sys->p_intf );
+
+    return VLC_SUCCESS;
+}
+
+/****************************************************************************
+ * DecodeBlock: the whole thing
+ ****************************************************************************
+ * This function must be fed with complete subtitles units.
+ ****************************************************************************/
+static void DecodeBlock( decoder_t *p_dec, block_t **pp_block )
+{
+    if( !pp_block || *pp_block == NULL )
+    {
+        return;
+    }
+
+    ParseText( p_dec, *pp_block );
+
+    block_Release( *pp_block );
+    *pp_block = NULL;
+}
+
+/*****************************************************************************
+ * CloseDecoder: clean up the decoder
+ *****************************************************************************/
+static void CloseDecoder( vlc_object_t *p_this )
+{
+    decoder_t *p_dec = (decoder_t *)p_this;
+    decoder_sys_t *p_sys = p_dec->p_sys;
+    intf_thread_t *p_intf;
+
+    /* Destroy the interface object/thread */
+    p_intf = vlc_object_find( p_dec, VLC_OBJECT_INTF, FIND_CHILD );
+    if( p_intf != NULL )
+    {
+#ifdef CMML_DEBUG
+        msg_Dbg( p_dec, "CMML decoder is freeing interface thread" );
+#endif
+        intf_StopThread( p_intf );
+        vlc_object_detach( p_intf );
+        vlc_object_release( p_intf );
+        intf_Destroy( p_intf );
+    }
+
+    p_sys->p_intf = NULL;
+
+    free( p_sys );
+}
+
+/*****************************************************************************
+ * ParseText: parse an text subtitle packet and send it to the video output
+ *****************************************************************************/
+static void ParseText( decoder_t *p_dec, block_t *p_block )
+{
+    char *psz_subtitle, *psz_cmml, *psz_url;
+    XTag *p_clip_parser, *p_anchor;
+    vlc_value_t val;
+
+    /* We cannot display a subpicture with no date */
+    if( p_block->i_pts == 0 )
+    {
+        msg_Warn( p_dec, "subtitle without a date" );
+        return;
+    }
+
+    /* Check validity of packet data */
+    if( p_block->i_buffer <= 1 ||  p_block->p_buffer[0] == '\0' )
+    {
+        msg_Warn( p_dec, "empty subtitle" );
+        return;
+    }
+
+    /* get anchor text from CMML */
+
+    /* Copy the whole CMML tag into our own buffer:
+       allocate i_buffer bytes + 1 for the terminating \0 */
+    if ( (psz_cmml = malloc( p_block->i_buffer + 1 )) == NULL )
+        return;
+    psz_cmml = memcpy( psz_cmml, p_block->p_buffer, p_block->i_buffer );
+    psz_cmml[p_block->i_buffer] = '\0'; /* terminate the string */
+#ifdef CMML_DEBUG
+    msg_Dbg( p_dec, "psz_cmml is \"%s\"", psz_cmml );
+#endif
+    
+    /* Parse the <clip> part of the CMML */
+    p_clip_parser = xtag_new_parse( psz_cmml, p_block->i_buffer );
+    if( !p_clip_parser )
+    {
+        msg_Warn( p_dec, "couldn't initialise <clip> parser" );
+        free( psz_cmml );
+        return;
+    }
+
+    /* Parse the anchor tag and get its contents */
+    p_anchor = xtag_first_child( p_clip_parser, "a" );
+    if( p_anchor != NULL )
+    {
+        psz_subtitle = xtag_get_pcdata( p_anchor );
+    }
+    else
+    {
+        psz_subtitle = strdup( " " );
+    }
+
+#ifdef CMML_DEBUG
+    msg_Dbg( p_dec, "psz_subtitle is \"%s\"", psz_subtitle );
+#endif
+
+    /* get URL from the current clip, if one exists */
+    psz_url = xtag_get_attribute( p_anchor, "href" );
+#ifdef CMML_DEBUG
+    msg_Dbg( p_dec, "psz_url is \"%s\"", psz_url );
+#endif
+    if( psz_url )
+    {
+        char *psz_tmp = strdup( psz_url );
+        
+        val.p_address = psz_tmp;
+        if( var_Set( p_dec, "psz-current-anchor-url", val ) != VLC_SUCCESS )
+        {
+            (void) var_Create( p_dec, "psz-current-anchor-url",
+                               VLC_VAR_ADDRESS|VLC_VAR_DOINHERIT );
+            msg_Dbg( p_dec, "creating psz-current-anchor-url" );
+            if( var_Set( p_dec, "psz-current-anchor-url", val ) != VLC_SUCCESS )
+                msg_Dbg( p_dec, "var_Set of psz-current-anchor-url failed" );
+        }
+    }
+
+    if( psz_subtitle )
+    {
+        char *psz_tmp = strdup( psz_subtitle );
+
+        val.p_address = psz_tmp;
+        if( var_Set( p_dec, "psz-current-anchor-description", val ) != VLC_SUCCESS )
+        {
+            (void) var_Create( p_dec, "psz-current-anchor-description",
+                               VLC_VAR_ADDRESS|VLC_VAR_DOINHERIT );
+            msg_Dbg( p_dec, "creating psz-current-anchor-description" );
+            if( var_Set( p_dec, "psz-current-anchor-description", val ) != VLC_SUCCESS )
+                msg_Dbg( p_dec, "var_Set of psz-current-anchor-description failed" );
+        }
+
+    }
+
+    if( psz_subtitle ) free( psz_subtitle );
+    if( psz_cmml ) free( psz_cmml );
+    if( p_anchor ) free( p_anchor );
+    if( p_clip_parser ) free( p_clip_parser );
+    if( psz_url ) free( psz_url );
+}
+

modules/codec/cmml/history.c

+/*****************************************************************************
+ * history.c: vlc_history_t (web-browser-like back/forward history) handling
+ *****************************************************************************
+ * Copyright (C) 2004 Commonwealth Scientific and Industrial Research
+ *                    Organisation (CSIRO) Australia
+ * Copyright (C) 2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Authors: Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include <vlc/vlc.h>
+
+#include "history.h"
+
+#include "xarray.h"
+
+#ifdef HAVE_STDLIB_H
+#   include <stdlib.h>                                          /* realloc() */
+#endif
+
+#undef HISTORY_DEBUG
+
+/*****************************************************************************
+ * Local prototypes
+ *****************************************************************************/
+static void history_Dump( history_t *p_history );
+
+/*****************************************************************************
+ * Local structure lock
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Actual history code
+ *****************************************************************************/
+
+history_t *history_New()
+{
+   history_t *p_new_history;
+   
+   p_new_history = calloc( 1, sizeof( struct history_t ) );
+   if( p_new_history == NULL ) return NULL;
+
+   p_new_history->p_xarray = xarray_New( 0 );
+   if( p_new_history->p_xarray == NULL )
+   {
+       free( p_new_history );
+       return NULL;
+   }
+
+#ifndef HISTORY_DEBUG
+   /* make dummy reference to history_Dump to avoid compiler warnings */
+   while (0)
+   {
+       void *p_tmp;
+
+       p_tmp = history_Dump;
+   }
+#endif
+
+   return p_new_history;
+}
+
+vlc_bool_t history_GoBackSavingCurrentItem ( history_t *p_history,
+                                             history_item_t *p_item )
+{
+    history_PruneAndInsert( p_history, p_item );
+
+    /* PruneAndInsert will increment the index, so we need to go
+     * back one position to reset the index to the place we were at
+     * before saving the current state, and then go back one more to
+     * actually go back */
+    p_history->i_index -= 2;
+
+#ifdef HISTORY_DEBUG
+    history_Dump( p_history );
+#endif
+    return VLC_TRUE;
+}
+
+static void history_Dump( history_t *p_history )
+{
+    unsigned int i_count;
+    int i;
+
+    if( xarray_Count( p_history->p_xarray, &i_count ) != XARRAY_SUCCESS )
+        return;
+
+    for (i = 0; i < (int) i_count; i++)
+    {
+        history_item_t *p_item;
+        void *pv_item;
+
+        xarray_ObjectAtIndex( p_history->p_xarray, i, &pv_item );
+        
+        p_item = (history_item_t *) pv_item;
+
+        if( p_item == NULL )
+            fprintf( stderr, "HISTORY: [%d] NULL\n", i );
+        else
+            fprintf( stderr, "HISTORY: [%d] %p (%p->%s)\n", i, p_item,
+                     p_item->psz_uri, p_item->psz_uri );
+    }
+}
+
+vlc_bool_t history_GoForwardSavingCurrentItem ( history_t *p_history,
+                                                history_item_t *p_item )
+{
+#ifdef HISTORY_DEBUG
+    history_Dump( p_history );
+#endif
+
+    if( xarray_ReplaceObject( p_history->p_xarray, p_history->i_index, p_item )
+        == XARRAY_SUCCESS )
+    {
+        p_history->i_index++;
+        return VLC_TRUE;
+    }
+    else
+    {
+        return VLC_FALSE;
+    }
+}
+
+vlc_bool_t history_CanGoBack( history_t *p_history )
+{
+    if( p_history->i_index > 0 )
+        return VLC_TRUE;
+    else
+        return VLC_FALSE;
+}
+
+vlc_bool_t history_CanGoForward( history_t *p_history )
+{
+    unsigned int i_count;
+
+    if( xarray_Count( p_history->p_xarray, &i_count ) != XARRAY_SUCCESS )
+        return VLC_FALSE;
+
+    if( p_history->i_index < i_count )
+        return VLC_TRUE;
+    else
+        return VLC_FALSE;
+}
+
+history_item_t *history_Item( history_t *p_history )
+{
+    history_item_t *p_item;
+    void *pv_item;
+
+    if( xarray_ObjectAtIndex( p_history->p_xarray, p_history->i_index,
+                              &pv_item )
+        == XARRAY_SUCCESS )
+    {
+        p_item = (history_item_t *) pv_item;
+        return p_item;
+    }
+    else
+    {
+        return NULL;
+    }
+}
+
+void history_Prune( history_t *p_history )
+{
+    xarray_RemoveObjectsAfter( p_history->p_xarray, p_history->i_index );
+    xarray_RemoveObject( p_history->p_xarray, p_history->i_index );
+}
+
+void history_PruneAndInsert( history_t *p_history, history_item_t *p_item )
+{
+    unsigned int i_count;
+
+    xarray_Count( p_history->p_xarray, &i_count );
+
+    if( i_count == 0 )
+    {
+        xarray_InsertObject( p_history->p_xarray, p_item, 0 );
+        p_history->i_index = 1;
+    }
+    else
+    {
+        history_Prune( p_history );
+        xarray_InsertObject( p_history->p_xarray, p_item, p_history->i_index );
+        p_history->i_index++;
+    }
+}
+
+unsigned int history_Count( history_t *p_history )
+{
+    int i_count;
+    xarray_Count( p_history->p_xarray, &i_count );
+    return i_count;
+}
+
+unsigned int history_Index( history_t *p_history )
+{
+    return p_history->i_index;
+}
+
+history_item_t * historyItem_New( char *psz_name, char *psz_uri )
+{
+    history_item_t *p_history_item = NULL;
+
+    p_history_item = (history_item_t *) malloc( sizeof(history_item_t) );
+    if( !p_history_item ) return NULL;
+
+    p_history_item->psz_uri = strdup( psz_uri );
+    p_history_item->psz_name = strdup( psz_name );
+
+    return p_history_item;
+}
+

modules/codec/cmml/history.h

+/*****************************************************************************
+ * history.h: vlc_history_t (web-browser-like back/forward history) handling
+ *****************************************************************************
+ * Copyright (C) 2004 Commonwealth Scientific and Industrial Research
+ *                    Organisation (CSIRO) Australia
+ * Copyright (C) 2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Authors: Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __VLC_HISTORY_H__
+#define __VLC_HISTORY_H__
+
+#define XARRAY_EMBED_IN_HOST_C_FILE
+#include "xarray.h"
+
+struct history_item_t
+{
+    char * psz_name;
+    char * psz_uri;
+};
+
+struct history_t
+{
+    unsigned int i_index; /* current index into history */
+    XArray * p_xarray;
+};
+
+typedef struct history_item_t history_item_t;
+typedef struct history_t history_t;
+
+
+/*****************************************************************************
+ * Exported prototypes
+ *****************************************************************************/
+history_t       * history_New                        ();
+vlc_bool_t        history_GoBackSavingCurrentItem    ( history_t *,
+                                                       history_item_t * );
+vlc_bool_t        history_GoForwardSavingCurrentItem ( history_t *,
+                                                       history_item_t * );
+vlc_bool_t        history_CanGoBack                  ( history_t * );
+vlc_bool_t        history_CanGoForward               ( history_t * );
+history_item_t  * history_Item                       ( history_t * );
+void              history_Prune                      ( history_t * );
+void              history_PruneAndInsert             ( history_t *,
+                                                       history_item_t * );
+unsigned int      history_Count                      ( history_t * );
+unsigned int      history_Index                      ( history_t * );
+
+history_item_t  * historyItem_New                    ( char *, char * );
+
+#endif /* __VLC_HISTORY_H__ */
+

modules/codec/cmml/xarray.c

+/*************************************************************************
+ * xarray.c: Mutable (dynamically growable) array
+ *************************************************************************
+ * Copyright (C) 2004 Commonwealth Scientific and Industrial Research
+ *                    Organisation (CSIRO) Australia
+ * Copyright (C) 2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Authors: Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ ************************************************************************/
+
+#include <stdlib.h>
+#include <string.h> /* memmove(1) */
+
+#include "xarray.h"
+
+#define XARRAY_ASSERT_NOT_NULL(xarray) \
+    { \
+        if (xarray == NULL) return XARRAY_ENULLPOINTER; \
+    }
+
+#define XARRAY_BOUNDS_CHECK(xarray, index) \
+    { \
+        if (index < 0) \
+            return XARRAY_ENEGATIVEINDEX; \
+        else if (xarray->last_valid_element != -1 && \
+                 (int) index > xarray->last_valid_element) \
+            return XARRAY_EINDEXTOOLARGE; \
+    }
+
+#define XARRAY_GROW_ARRAY(xarray) \
+    { \
+        xarray->array = (void *) realloc (xarray->array, xarray->size * 2); \
+        if (xarray->array == NULL) return XARRAY_ENOMEM; \
+    }
+
+XSTATIC XArray * xarray_New (unsigned int initial_size_hint)
+{
+    XArray *new_xarray = NULL;
+    void *inner_array;
+    unsigned int initial_size;
+
+    new_xarray = (XArray *) malloc (sizeof(XArray));
+    if (new_xarray == NULL) return NULL;
+
+    if (initial_size_hint <= 0)
+        initial_size = XARRAY_DEFAULT_SIZE;
+    else
+        initial_size = initial_size_hint;
+
+    inner_array = calloc (initial_size, sizeof(void *));
+
+    new_xarray->last_valid_element = -1;
+    new_xarray->size = initial_size;
+    new_xarray->last_error = 0;
+
+    if (inner_array == NULL)
+    {
+        free (new_xarray);
+        return NULL;
+    }
+
+    new_xarray->array = inner_array;
+
+    /* Make a dummy reference to other functions, so that we don't get
+     * warnings about unused functions from the compiler.  Ahem :) */
+    while (0)
+    {
+        void *dummy_reference;
+
+        dummy_reference = xarray_AddObject;
+        dummy_reference = xarray_InsertObject;
+        dummy_reference = xarray_RemoveLastObject;
+        dummy_reference = xarray_RemoveObject;
+        dummy_reference = xarray_RemoveObjects;
+        dummy_reference = xarray_RemoveObjectsAfter;
+        dummy_reference = xarray_ReplaceObject;
+
+        dummy_reference = xarray_ObjectAtIndex;
+        dummy_reference = xarray_Count;
+    }
+    
+    return new_xarray;
+}
+
+XSTATIC int xarray_ObjectAtIndex (XArray *xarray, unsigned int index,
+        void **out_object)
+{
+    XARRAY_ASSERT_NOT_NULL (xarray);
+    XARRAY_BOUNDS_CHECK (xarray, index);
+
+    *out_object = xarray->array[index];
+
+    return XARRAY_SUCCESS;
+}
+
+XSTATIC int xarray_AddObject (XArray *xarray, void *object)
+{
+    XARRAY_ASSERT_NOT_NULL (xarray);
+
+    ++xarray->last_valid_element;
+    if (xarray->last_valid_element >= (int) xarray->size)
+    {
+        XARRAY_GROW_ARRAY (xarray);
+    }
+
+    xarray->array[xarray->last_valid_element] = object;
+
+    return XARRAY_SUCCESS;
+}
+
+XSTATIC int xarray_InsertObject (XArray *xarray, void *object,
+        unsigned int at_index)
+{
+    XARRAY_ASSERT_NOT_NULL (xarray);
+    ++xarray->last_valid_element;
+    XARRAY_BOUNDS_CHECK (xarray, at_index);
+    if (xarray->last_valid_element >= (int) xarray->size)
+    {
+        XARRAY_GROW_ARRAY (xarray);
+    }
+
+    /* Shift everything from a[i] onward one pointer forward */
+
+    if ((int) at_index < xarray->last_valid_element)
+    {
+        (void) memmove (&xarray->array[at_index + 1],
+                        &xarray->array[at_index],
+                        (xarray->last_valid_element - at_index) *
+                            sizeof(void *));
+    }
+
+    xarray->array[at_index] = object;
+
+    return XARRAY_SUCCESS;
+}
+
+XSTATIC int xarray_RemoveLastObject (XArray *xarray)
+{
+    XARRAY_ASSERT_NOT_NULL (xarray);
+
+    if (xarray->last_valid_element == -1)
+        return XARRAY_EEMPTYARRAY;
+
+    xarray->array[xarray->last_valid_element] = NULL;
+    --xarray->last_valid_element;
+
+    return XARRAY_SUCCESS;
+}
+
+XSTATIC int xarray_RemoveObject (XArray *xarray, unsigned int at_index)
+{
+    XARRAY_ASSERT_NOT_NULL (xarray);
+    XARRAY_BOUNDS_CHECK (xarray, at_index);
+
+    /* Shift everything from a[i] onward one pointer backward */
+
+    if ((int) at_index < xarray->last_valid_element)
+    {
+        (void) memmove (&xarray->array[at_index],
+                        &xarray->array[at_index + 1],
+                        (xarray->last_valid_element - at_index) *
+                            sizeof(void *));
+    }
+
+    xarray->array[xarray->last_valid_element] = NULL;
+    --xarray->last_valid_element;
+
+    return XARRAY_SUCCESS;    
+}
+
+XSTATIC int xarray_RemoveObjects (XArray *xarray, unsigned int at_index,
+        int count)
+{
+    int i;
+
+    XARRAY_ASSERT_NOT_NULL (xarray);
+    XARRAY_BOUNDS_CHECK (xarray, at_index);
+
+    if (count == 0) return XARRAY_SUCCESS;
+
+    if ((int) at_index + (count - 1) > xarray->last_valid_element)
+        return XARRAY_ECOUNTOUTOFBOUNDS;
+
+    for (i = 0; i < count; i++)
+    {
+        int e = xarray_RemoveObject (xarray, at_index);
+        if (e != XARRAY_SUCCESS) return e;
+    }
+
+    return XARRAY_SUCCESS;
+}
+
+XSTATIC int xarray_RemoveObjectsAfter (XArray *xarray, unsigned int index)
+{
+    XARRAY_ASSERT_NOT_NULL (xarray);
+    XARRAY_BOUNDS_CHECK (xarray, index);
+
+    index++;
+
+    while ((int) index <= xarray->last_valid_element)
+    {
+        int e = xarray_RemoveObject (xarray, index);
+        if (e != XARRAY_SUCCESS) return e;
+    }
+
+    return XARRAY_SUCCESS;
+}
+
+XSTATIC int xarray_ReplaceObject (XArray *xarray, unsigned int index,
+        void *new_object)
+{
+    XARRAY_ASSERT_NOT_NULL (xarray);
+    XARRAY_BOUNDS_CHECK (xarray, index);
+
+    xarray->array[index] = new_object;
+
+    return XARRAY_SUCCESS;
+}
+
+XSTATIC int xarray_Count (XArray *xarray, unsigned int *out_count)
+{
+    XARRAY_ASSERT_NOT_NULL (xarray);
+
+    *out_count = xarray->last_valid_element + 1;
+
+    return XARRAY_SUCCESS;
+}
+
+
+#undef XARRAY_ASSERT_NOT_NULL
+#undef XARRAY_BOUNDS_CHECK
+#undef XARRAY_GROW_ARRAY
+

modules/codec/cmml/xarray.h

+/*************************************************************************
+ * xarray.h: Mutable (dynamically growable) array (header file)
+ *************************************************************************
+ * Copyright (C) 2004 Commonwealth Scientific and Industrial Research
+ *                    Organisation (CSIRO) Australia
+ * Copyright (C) 2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Authors: Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ ************************************************************************/
+
+#ifndef __XARRAY_H__
+#define __XARRAY_H__
+
+/* define this to 'static' for static linkage */
+#define XSTATIC
+
+#define XARRAY_DEFAULT_SIZE 69
+#define xarray_malloc malloc
+
+/* Error codes */
+enum xarray_errors
+{
+    XARRAY_SUCCESS, XARRAY_ENULLPOINTER, XARRAY_ENEGATIVEINDEX,
+    XARRAY_EINDEXTOOLARGE, XARRAY_ENOMEM, XARRAY_EEMPTYARRAY,
+    XARRAY_ECOUNTOUTOFBOUNDS
+};
+
+
+typedef struct
+{
+    void **array;
+    int last_valid_element;
+    unsigned int size;
+    unsigned int last_error;
+}
+XArray;
+
+/* Mutable methods */
+XSTATIC int      xarray_AddObject (XArray *xarray, void *object);
+XSTATIC int      xarray_InsertObject (XArray *xarray, void *object,
+                                      unsigned int at_index);
+XSTATIC int      xarray_RemoveLastObject (XArray *xarray);
+XSTATIC int      xarray_RemoveObject (XArray *xarray, unsigned int at_index);
+XSTATIC int      xarray_RemoveObjects (XArray *xarray, unsigned int at_index,
+                                       int count);
+XSTATIC int      xarray_RemoveObjectsAfter (XArray *xarray, unsigned int index);
+XSTATIC int      xarray_ReplaceObject (XArray *xarray, unsigned int index,
+                                       void *new_object);
+
+/* Immutable methods */
+XSTATIC XArray * xarray_New ();
+XSTATIC int      xarray_ObjectAtIndex (XArray *xarray, unsigned int index,
+                                       void **out_object);
+XSTATIC int      xarray_Count (XArray *xarray, unsigned int *out_count);
+
+#endif /* __XARRAY_H__ */
+

modules/codec/cmml/xlist.c

+/*****************************************************************************
+ * xlist.c : a simple doubly linked list in C
+ *****************************************************************************
+ * Copyright (C) 2003-2004 Commonwealth Scientific and Industrial Research
+ *                         Organisation (CSIRO) Australia
+ * Copyright (C) 2000-2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Authors: Conrad Parker <Conrad.Parker@csiro.au>
+ *          Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#include <stdlib.h>
+
+#include "xlist.h"
+
+static XList *
+xlist_node_new (void * data)
+{
+  XList * l;
+
+  l = (XList *) malloc (sizeof (XList));
+  l->prev = l->next = NULL;
+  l->data = data;
+
+  return l;
+}
+
+XList *
+xlist_new (void)
+{
+  return NULL;
+}
+
+XList *
+xlist_clone (XList * list)
+{
+  XList * l, * new_list;
+
+  if (list == NULL) return NULL;
+  new_list = xlist_new ();
+
+  for (l = list; l; l = l->next) {
+    new_list = xlist_append (new_list, l->data);
+  }
+
+  return new_list;
+}
+
+XList *
+xlist_clone_with (XList * list, XCloneFunc clone)
+{
+  XList * l, * new_list;
+  void * new_data;
+
+  if (list == NULL) return NULL;
+  if (clone == NULL) return xlist_clone (list);
+
+  new_list = xlist_new ();
+
+  for (l = list; l; l = l->next) {
+    new_data = clone (l->data);
+    new_list = xlist_append (new_list, new_data);
+  }
+
+  return new_list;
+}
+
+
+XList *
+xlist_tail (XList * list)
+{
+  XList * l;
+  for (l = list; l; l = l->next)
+    if (l->next == NULL) return l;
+  return NULL;
+}
+
+XList *
+xlist_prepend (XList * list, void * data)
+{
+  XList * l = xlist_node_new (data);
+
+  if (list == NULL) return l;
+
+  l->next = list;
+  list->prev = l;
+
+  return l;
+}
+
+XList *
+xlist_append (XList * list, void * data)
+{
+  XList * l = xlist_node_new (data);
+  XList * last;
+
+  if (list == NULL) return l;
+
+  last = xlist_tail (list);
+  if (last) last->next = l;
+  l->prev = last; 
+  return list;
+}
+
+XList *
+xlist_add_before (XList * list, void * data, XList * node)
+{
+  XList * l, * p;
+
+  if (list == NULL) return xlist_node_new (data);
+  if (node == NULL) return xlist_append (list, data);
+  if (node == list) return xlist_prepend (list, data);
+
+  l = xlist_node_new (data);
+  p = node->prev;
+
+  l->prev = p;
+  l->next = node;
+  if (p) p->next = l;
+  node->prev = l;
+  
+  return list;
+}
+
+XList *
+xlist_add_after (XList * list, void * data, XList * node)
+{
+  XList * l, * n;
+
+  if (node == NULL) return xlist_prepend (list, data);
+
+  l = xlist_node_new (data);
+  n = node->next;
+
+  l->prev = node;
+  l->next = n;
+  if (n) n->prev = l;
+  node->next = l;
+
+  return list;
+}
+
+XList *
+xlist_find (XList * list, void * data)
+{
+  XList * l;
+
+  for (l = list; l; l = l->next)
+    if (l->data == data) return l;
+
+  return NULL;
+}
+
+XList *
+xlist_remove (XList * list, XList * node)
+{
+  if (node == NULL) return list;
+
+  if (node->prev) node->prev->next = node->next;
+  if (node->next) node->next->prev = node->prev;
+
+  if (node == list) return list->next;
+  else return list;
+}
+
+int
+xlist_length (XList * list)
+{
+  XList * l;
+  int c = 0;
+
+  for (l = list; l; l = l->next)
+    c++;
+
+  return c;
+}
+
+int
+xlist_is_empty (XList * list)
+{
+  return (list == NULL);
+}
+
+int
+xlist_is_singleton (XList * list)
+{
+  if (list == NULL) return 0;
+  if (list->next == NULL) return 1;
+  else return 0;
+}
+
+/*
+ * xlist_free_with (list, free_func)
+ *
+ * Step through list 'list', freeing each node using free_func(), and
+ * also free the list structure itself.
+ */
+XList *
+xlist_free_with (XList * list, XFreeFunc free_func)
+{
+  XList * l, * ln;
+
+  for (l = list; l; l = ln) {
+    ln = l->next;
+    free_func (l->data);
+    free (l);
+  }
+
+  return NULL;
+}
+
+/*
+ * xlist_free (list)
+ *
+ * Free the list structure 'list', but not its nodes.
+ */
+XList *
+xlist_free (XList * list)
+{
+  XList * l, * ln;
+
+  for (l = list; l; l = ln) {
+    ln = l->next;
+    free (l);
+  }
+
+  return NULL;
+}
+

modules/codec/cmml/xlist.h

+/*****************************************************************************
+ * xlist.h : a simple doubly linked list in C (header file)
+ *****************************************************************************
+ * Copyright (C) 2003-2004 Commonwealth Scientific and Industrial Research
+ *                         Organisation (CSIRO) Australia
+ * Copyright (C) 2000-2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Authors: Conrad Parker <Conrad.Parker@csiro.au>
+ *          Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+
+#ifndef __XLIST__
+#define __XLIST__
+
+/**
+ * A doubly linked list
+ */
+typedef struct _XList XList;
+
+struct _XList {
+  XList * prev;
+  XList * next;
+  void * data;
+};
+
+/**
+ * Signature of a cloning function.
+ */
+typedef void * (*XCloneFunc) (void * data);
+
+/**
+ * Signature of a freeing function.
+ */
+typedef void * (*XFreeFunc) (void * data);
+
+/** Create a new list
+ * \return a new list
+ */
+XList * xlist_new (void);
+
+/**
+ * Clone a list using the default clone function
+ * \param list the list to clone
+ * \returns a newly cloned list
+ */
+XList * xlist_clone (XList * list);
+
+/**
+ * Clone a list using a custom clone function
+ * \param list the list to clone
+ * \param clone the function to use to clone a list item
+ * \returns a newly cloned list
+ */
+XList * xlist_clone_with (XList * list, XCloneFunc clone);
+
+/**
+ * Return the tail element of a list
+ * \param list the list
+ * \returns the tail element
+ */
+XList * xlist_tail (XList * list);
+
+/**
+ * Prepend a new node to a list containing given data
+ * \param list the list
+ * \param data the data element of the newly created node
+ * \returns the new list head
+ */
+XList * xlist_prepend (XList * list, void * data);
+
+/**
+ * Append a new node to a list containing given data
+ * \param list the list
+ * \param data the data element of the newly created node
+ * \returns the head of the list
+ */
+XList * xlist_append (XList * list, void * data);
+
+/**
+ * Add a new node containing given data before a given node
+ * \param list the list
+ * \param data the data element of the newly created node
+ * \param node the node before which to add the newly created node
+ * \returns the head of the list (which may have changed)
+ */
+XList * xlist_add_before (XList * list, void * data, XList * node);
+
+/**
+ * Add a new node containing given data after a given node
+ * \param list the list
+ * \param data the data element of the newly created node
+ * \param node the node after which to add the newly created node
+ * \returns the head of the list
+ */
+XList * xlist_add_after (XList * list, void * data, XList * node);
+
+/**
+ * Find the first node containing given data in a list
+ * \param list the list
+ * \param data the data element to find
+ * \returns the first node containing given data, or NULL if it is not found
+ */
+XList * xlist_find (XList * list, void * data);
+
+/**
+ * Remove a node from a list
+ * \param list the list
+ * \param node the node to remove
+ * \returns the head of the list (which may have changed)
+ */
+XList * xlist_remove (XList * list, XList * node);
+
+/**
+ * Query the number of items in a list
+ * \param list the list
+ * \returns the number of nodes in the list
+ */
+int xlist_length (XList * list);
+
+/**
+ * Query if a list is empty, ie. contains no items
+ * \param list the list
+ * \returns 1 if the list is empty, 0 otherwise
+ */
+int xlist_is_empty (XList * list);
+
+/**
+ * Query if the list is singleton, ie. contains exactly one item
+ * \param list the list
+ * \returns 1 if the list is singleton, 0 otherwise
+ */
+int xlist_is_singleton (XList * list);
+
+/**
+ * Free a list, using a given function to free each data element
+ * \param list the list
+ * \param free_func a function to free each data element
+ * \returns NULL on success
+ */
+XList * xlist_free_with (XList * list, XFreeFunc free_func);
+
+/**
+ * Free a list, using anx_free() to free each data element
+ * \param list the list
+ * \returns NULL on success
+ */
+XList * xlist_free (XList * list);
+
+#endif /* __XLIST__ */
+
+

modules/codec/cmml/xstrcat.h

+/*****************************************************************************
+ * xstrcat.h: strcat with realloc
+ *****************************************************************************
+ * Copyright (C) 2004 Commonwealth Scientific and Industrial Research
+ *                    Organisation (CSIRO) Australia
+ * Copyright (C) 2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Authors: Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __XSTRCAT_H__
+#define __XSTRCAT_H__
+
+/* like strcat, but realloc's enough memory for the new string too */
+
+static inline
+char *xstrcat( char *psz_string, char *psz_to_append )
+{
+    size_t i_new_string_length = strlen( psz_string ) +
+        strlen( psz_to_append ) + 1;
+
+    psz_string = (char *) realloc( psz_string, i_new_string_length );
+    
+    return strcat( psz_string, psz_to_append );
+}
+
+#endif /* __XSTRCAT_H__ */
+

modules/codec/cmml/xtag.h

+/*****************************************************************************
+ * xlist.h : a trivial parser for XML-like tags (header file)
+ *****************************************************************************
+ * Copyright (C) 2003-2004 Commonwealth Scientific and Industrial Research
+ *                         Organisation (CSIRO) Australia
+ * Copyright (C) 2000-2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Authors: Conrad Parker <Conrad.Parker@csiro.au>
+ *          Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __XTAG_H__
+#define __XTAG_H__
+
+typedef void XTag;
+
+XTag * xtag_new_parse (const char * s, int n);
+
+char * xtag_get_name (XTag * xtag);
+
+char * xtag_get_pcdata (XTag * xtag);
+
+char * xtag_get_attribute (XTag * xtag, char * attribute);
+
+XTag * xtag_first_child (XTag * xtag, char * name);
+
+XTag * xtag_next_child (XTag * xtag, char * name);
+
+XTag * xtag_free (XTag * xtag);
+
+int xtag_snprint (char * buf, int n, XTag * xtag);
+
+#endif /* __XTAG_H__ */

modules/codec/cmml/xurl.h

+/*****************************************************************************
+ * xurl.h: URL manipulation functions (header file)
+ *****************************************************************************
+ * Copyright (C) 2003-2004 Commonwealth Scientific and Industrial Research
+ *                         Organisation (CSIRO) Australia
+ * Copyright (C) 2004 VideoLAN
+ *
+ * $Id$
+ *
+ * Authors: Andre Pang <Andre.Pang@csiro.au>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#ifndef __XURL_H__
+#define __XURL_H__
+
+#include <vlc/vlc.h>
+
+/* Specialise boolean definitions to VLC's boolean types */
+typedef vlc_bool_t XURL_Bool;
+#define XURL_FALSE VLC_FALSE
+#define XURL_TRUE VLC_TRUE
+
+/* Specialise general C functions to VLC's standards */
+#define xurl_malloc malloc
+#define xurl_free free
+
+/* Use DOS/Windows path separators? */
+#ifdef WIN32
+#  define XURL_WIN32_PATHING
+#else
+#  undef  XURL_WIN32_PATHING
+#endif
+
+/* Debugging */
+#undef XURL_DEBUG
+
+char *      XURL_Join                   ( char *psz_url1, char *psz_url2 );
+char *      XURL_Concat                 ( char *psz_url,  char *psz_append );
+
+XURL_Bool   XURL_IsAbsolute             ( char *psz_url );
+XURL_Bool   XURL_HasAbsolutePath        ( char *psz_url );
+XURL_Bool   XURL_IsFileURL              ( char *psz_url );
+XURL_Bool   XURL_HasFragment            ( char *psz_url );
+
+char *      XURL_GetHostname            ( char *psz_url );
+char *      XURL_GetSchemeAndHostname   ( char *psz_url );
+char *      XURL_GetScheme              ( char *psz_url );
+char *      XURL_GetPath                ( char *psz_url );
+char *      XURL_GetWithoutFragment     ( char *psz_url );
+
+char *      XURL_GetHead                ( const char *psz_path );
+
+#endif /* __XURL_H__ */
+