Commit 84cad9ba authored by Andre Pang's avatar Andre Pang

* Added Continuous Media Markup Language (CMML) codec

parent 87a35e06
......@@ -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
......
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
......
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
/*****************************************************************************
* 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
}
/*****************************************************************************
* 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__ */
/*****************************************************************************
* 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 );
}
/*****************************************************************************
* 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;
}
/*****************************************************************************
* 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__ */
This diff is collapsed.
/*************************************************************************
* 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
/*************************************************************************
* 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__ */
/*****************************************************************************
* 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;
}
/*****************************************************************************
* 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__ */
/*****************************************************************************
* 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__ */
This diff is collapsed.
/*****************************************************************************
* 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__ */
This diff is collapsed.
/*****************************************************************************
* 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__ */
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment