diff options
Diffstat (limited to 'src/xine-utils')
32 files changed, 1089 insertions, 2131 deletions
diff --git a/src/xine-utils/Makefile.am b/src/xine-utils/Makefile.am index 95de06b9e..6509f1178 100644 --- a/src/xine-utils/Makefile.am +++ b/src/xine-utils/Makefile.am @@ -1,23 +1,27 @@ include $(top_srcdir)/misc/Makefile.common -LIBTOOL = $(SHELL) $(top_builddir)/libtool -noinst_LTLIBRARIES = libxineutils.la +AM_CFLAGS = $(DEFAULT_OCFLAGS) $(X_CFLAGS) $(VISIBILITY_FLAG) +AM_CPPFLAGS = -DXINE_LIBRARY_COMPILE EXTRA_DIST = ppcasm_string.S ppc_asm.tmpl -if PPC_ARCH +noinst_HEADERS = ppcasm_string.h xine_check.h + +noinst_LTLIBRARIES = libxineutils.la + +if ARCH_PPC if !HOST_OS_DARWIN pppc_files = ppcasm_string.S endif endif -AM_CFLAGS = $(X_CFLAGS) $(VISIBILITY_FLAG) -AM_CPPFLAGS=-DXINE_LIBRARY_COMPILE - libxineutils_la_SOURCES = $(pppc_files) \ + base64.h \ + base64.c \ cpu_accel.c \ color.c \ copy.c \ + crc.c \ list.c \ memcpy.c \ monitor.c \ @@ -31,20 +35,3 @@ libxineutils_la_SOURCES = $(pppc_files) \ sorted_array.c \ pool.c \ ring_buffer.c - -xineinclude_HEADERS = \ - attributes.h \ - compat.h \ - xine_buffer.h \ - xineutils.h \ - xmllexer.h \ - xmlparser.h \ - list.h \ - array.h \ - sorted_array.h \ - pool.h \ - ring_buffer.h - - -noinst_HEADERS = ppcasm_string.h xine_check.h - diff --git a/src/xine-utils/array.c b/src/xine-utils/array.c index 6c226c7ef..0db45be0c 100644 --- a/src/xine-utils/array.c +++ b/src/xine-utils/array.c @@ -23,8 +23,8 @@ #include <stdlib.h> #include <string.h> -#include "attributes.h" -#include "array.h" +#include <xine/attributes.h> +#include <xine/array.h> #define MIN_CHUNK_SIZE 32 @@ -56,7 +56,7 @@ xine_array_t *xine_array_new(size_t initial_size) { if (initial_size < MIN_CHUNK_SIZE) initial_size = MIN_CHUNK_SIZE; - new_array->chunk = (void**)malloc(sizeof(void*) * initial_size); + new_array->chunk = (void**)calloc(initial_size, sizeof(void*)); if (!new_array->chunk) { free(new_array); return NULL; diff --git a/src/xine-utils/array.h b/src/xine-utils/array.h deleted file mode 100644 index ae2093823..000000000 --- a/src/xine-utils/array.h +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright (C) 2000-2006 the xine project - * - * This file is part of xine, a free video player. - * - * xine 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. - * - * xine is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA - * - * Array that can grow automatically when you add elements. - * Inserting an element in the middle of the array implies memory moves. - */ -#ifndef XINE_ARRAY_H -#define XINE_ARRAY_H - -/* Array type */ -typedef struct xine_array_s xine_array_t; - -/* Constructor */ -xine_array_t *xine_array_new(size_t initial_size) XINE_PROTECTED; - -/* Destructor */ -void xine_array_delete(xine_array_t *array) XINE_PROTECTED; - -/* Returns the number of element stored in the array */ -size_t xine_array_size(const xine_array_t *array) XINE_PROTECTED; - -/* Removes all elements from an array */ -void xine_array_clear(xine_array_t *array) XINE_PROTECTED; - -/* Adds the element at the end of the array */ -void xine_array_add(xine_array_t *array, void *value) XINE_PROTECTED; - -/* Inserts an element into an array at the position specified */ -void xine_array_insert(xine_array_t *array, unsigned int position, void *value) XINE_PROTECTED; - -/* Removes one element from an array at the position specified */ -void xine_array_remove(xine_array_t *array, unsigned int position) XINE_PROTECTED; - -/* Get the element at the position specified */ -void *xine_array_get(const xine_array_t *array, unsigned int position) XINE_PROTECTED; - -/* Set the element at the position specified */ -void xine_array_set(xine_array_t *array, unsigned int position, void *value) XINE_PROTECTED; - -#endif - diff --git a/src/xine-utils/attributes.h b/src/xine-utils/attributes.h deleted file mode 100644 index 563832e5c..000000000 --- a/src/xine-utils/attributes.h +++ /dev/null @@ -1,86 +0,0 @@ -/* - * attributes.h - * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca> - * Copyright (C) 2001-2007 xine developers - * - * This file was originally part of mpeg2dec, a free MPEG-2 video stream - * decoder. - * - * mpeg2dec 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. - * - * mpeg2dec is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA - */ - -/* use gcc attribs to align critical data structures */ - -#ifndef ATTRIBUTE_H_ -#define ATTRIBUTE_H_ - -#ifdef ATTRIBUTE_ALIGNED_MAX -#define ATTR_ALIGN(align) __attribute__ ((__aligned__ ((ATTRIBUTE_ALIGNED_MAX < align) ? ATTRIBUTE_ALIGNED_MAX : align))) -#else -#define ATTR_ALIGN(align) -#endif - -/* disable GNU __attribute__ extension, when not compiling with GNU C */ -#if defined(__GNUC__) || defined (__ICC) -#ifndef ATTRIBUTE_PACKED -#define ATTRIBUTE_PACKED 1 -#endif -#else -#undef ATTRIBUTE_PACKED -#ifndef __attribute__ -#define __attribute__(x) /**/ -#endif /* __attribute __*/ -#endif - -#ifdef XINE_COMPILE -# include "configure.h" -#endif - -/* Export protected only for libxine functions */ -#if defined(XINE_LIBRARY_COMPILE) && defined(SUPPORT_ATTRIBUTE_VISIBILITY_PROTECTED) -# define XINE_PROTECTED __attribute__((__visibility__("protected"))) -#elif defined(XINE_LIBRARY_COMPILE) && defined(SUPPORT_ATTRIBUTE_VISIBILITY_DEFAULT) -# define XINE_PROTECTED __attribute__((__visibility__("default"))) -#else -# define XINE_PROTECTED -#endif - -#ifdef SUPPORT_ATTRIBUTE_SENTINEL -# define XINE_SENTINEL __attribute__((__sentinel__)) -#else -# define XINE_SENTINEL -#endif - -#ifndef __attr_unused -# ifdef SUPPORT_ATTRIBUTE_UNUSED -# define __attr_unused __attribute__((__unused__)) -# else -# define __attr_unused -# endif -#endif - -/* Format attributes */ -#ifdef SUPPORT_ATTRIBUTE_FORMAT -# define XINE_FORMAT_PRINTF(fmt,var) __attribute__((__format__(__printf__, fmt, var))) -#else -# define XINE_FORMAT_PRINTF(fmt,var) -#endif -#ifdef SUPPORT_ATTRIBUTE_FORMAT_ARG -# define XINE_FORMAT_PRINTF_ARG(fmt) __attribute__((__format_arg__(fmt))) -#else -# define XINE_FORMAT_PRINTF_ARG(fmt) -#endif - -#endif /* ATTRIBUTE_H_ */ diff --git a/src/xine-utils/base64.c b/src/xine-utils/base64.c new file mode 100644 index 000000000..5730f30db --- /dev/null +++ b/src/xine-utils/base64.c @@ -0,0 +1,198 @@ +/* + * Copyright (C) 2000 Robert Kaye + * + * This file is part of xine, a free video player. + * + * xine 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. + * + * xine is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA + * + * Base64 encoding modified for Musicbrainz + * relicensed under the GNU General Public License for use in xine-lib + */ +/* -------------------------------------------------------------------------- + + MusicBrainz -- The Internet music metadatabase + + Copyright (C) 2000 Robert Kaye + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA + +----------------------------------------------------------------------------*/ +/* + * Program: RFC-822 routines (originally from SMTP) + * + * Author: Mark Crispin + * Networks and Distributed Computing + * Computing & Communications + * University of Washington + * Administration Building, AG-44 + * Seattle, WA 98195 + * Internet: MRC@CAC.Washington.EDU + * + * Date: 27 July 1988 + * Last Edited: 10 September 1998 + * + * Sponsorship: The original version of this work was developed in the + * Symbolic Systems Resources Group of the Knowledge Systems + * Laboratory at Stanford University in 1987-88, and was funded + * by the Biomedical Research Technology Program of the National + * Institutes of Health under grant number RR-00785. + * + * Original version Copyright 1988 by The Leland Stanford Junior University + * Copyright 1998 by the University of Washington + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notices appear in all copies and that both the + * above copyright notices and this permission notice appear in supporting + * documentation, and that the name of the University of Washington or The + * Leland Stanford Junior University not be used in advertising or publicity + * pertaining to distribution of the software without specific, written prior + * permission. This software is made available "as is", and + * THE UNIVERSITY OF WASHINGTON AND THE LELAND STANFORD JUNIOR UNIVERSITY + * DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO THIS SOFTWARE, + * INCLUDING WITHOUT LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE, AND IN NO EVENT SHALL THE UNIVERSITY OF + * WASHINGTON OR THE LELAND STANFORD JUNIOR UNIVERSITY BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER + * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF + * CONTRACT, TORT (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <ctype.h> +#include <stdio.h> +#include <time.h> +#include <stdlib.h> + +#include "base64.h" + + +/* NOTE: This is not true RFC822 anymore. The use of the characters + '/', '+', and '=' is no bueno when the ID will be used as part of a URL. + '_', '.', and '-' have been used instead +*/ + +/* Convert binary contents to BASE64 + * Accepts: source + * length of source + * pointer to return destination length + * Returns: destination as BASE64 + */ + +unsigned char *_x_rfc822_binary (void *src,unsigned long srcl,unsigned long *len) +{ + unsigned char *ret,*d; + unsigned char *s = (unsigned char *) src; + static const char v[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._"; + unsigned long i = ((srcl + 2) / 3) * 4; + *len = i += 2 * ((i / 60) + 1); + d = ret = (unsigned char *) malloc ((size_t) ++i); + for (i = 0; srcl; s += 3) { /* process tuplets */ + *d++ = v[s[0] >> 2]; /* byte 1: high 6 bits (1) */ + /* byte 2: low 2 bits (1), high 4 bits (2) */ + *d++ = v[((s[0] << 4) + (--srcl ? (s[1] >> 4) : 0)) & 0x3f]; + /* byte 3: low 4 bits (2), high 2 bits (3) */ + *d++ = srcl ? v[((s[1] << 2) + (--srcl ? (s[2] >> 6) : 0)) & 0x3f] : '-'; + /* byte 4: low 6 bits (3) */ + *d++ = srcl ? v[s[2] & 0x3f] : '-'; + if (srcl) srcl--; /* count third character if processed */ + if ((++i) == 15) { /* output 60 characters? */ + i = 0; /* restart line break count, insert CRLF */ + *d++ = '\015'; *d++ = '\012'; + } + } + *d = '\0'; /* tie off string */ + + return ret; /* return the resulting string */ +} + +char *_x_base64_encode (const void *src, unsigned long srcl, unsigned long *len) +{ + char *ret, *d; + unsigned char *s = (unsigned char *) src; + char *v = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._"; + unsigned long i = ((srcl + 2) / 3) * 4; + *len = i; + d = ret = (char *) malloc ((size_t) ++i); + for (i = 0; srcl; s += 3) { /* process tuplets */ + *d++ = v[s[0] >> 2]; /* byte 1: high 6 bits (1) */ + /* byte 2: low 2 bits (1), high 4 bits (2) */ + *d++ = v[((s[0] << 4) + (--srcl ? (s[1] >> 4) : 0)) & 0x3f]; + /* byte 3: low 4 bits (2), high 2 bits (3) */ + *d++ = srcl ? v[((s[1] << 2) + (--srcl ? (s[2] >> 6) : 0)) & 0x3f] : '-'; + /* byte 4: low 6 bits (3) */ + *d++ = srcl ? v[s[2] & 0x3f] : '-'; + if (srcl) srcl--; /* count third character if processed */ + } + *d = '\0'; /* tie off string */ + + return ret; /* return the resulting string */ +} + +void *_x_base64_decode (const char *src, unsigned long srcl, unsigned long *len) +{ + void *ret; + unsigned char *d; + unsigned long i = ((srcl + 3) / 4) * 3; + *len = i; + d = ret = (void *) malloc ((size_t)i); + for (i = 0; srcl; src += 4) { /* process tuplets */ + unsigned char tuplet[4]; + int j; + + for (j = 0; j < 4; j += 1) { + if (srcl) { + if ((src[j] >= 'A') && (src[j] <= 'Z')) { + tuplet[j] = src[j] - 'A'; + } else if ((src[j] >= 'a') && (src[j] <= 'z')) { + tuplet[j] = src[j] - 'a' + 26; + } else if ((src[j] >= '0') && (src[j] <= '9')) { + tuplet[j] = src[j] - '0' + 52; + } else if (src[j] == '.') { + tuplet[j] = 62; + } else if (src[j] == '_') { + tuplet[j] = 63; + } else { + tuplet[j] = 64; + } + srcl--; + } else { + (*len)--; + } + } + + *d++ = (tuplet[0] << 2) + ((tuplet[1] & 0x3f) >> 4); + *d++ = (tuplet[1] << 4) + ((tuplet[2] & 0x3f) >> 2); + *d++ = (tuplet[2] << 6) + (tuplet[3] & 0x3f); + } + + return ret; /* return the resulting string */ +} diff --git a/src/xine-utils/base64.h b/src/xine-utils/base64.h new file mode 100644 index 000000000..f22f9b0c4 --- /dev/null +++ b/src/xine-utils/base64.h @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2000 Robert Kaye + * + * This file is part of xine, a free video player. + * + * xine 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. + * + * xine is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA + * + * Base64 encoding modified for Musicbrainz + * relicensed under the GNU General Public License for use in xine-lib + */ +/* -------------------------------------------------------------------------- + + MusicBrainz -- The Internet music metadatabase + + Copyright (C) 2000 Robert Kaye + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA + +----------------------------------------------------------------------------*/ +/* + * Program: RFC-822 routines (originally from SMTP) + * + * Author: Mark Crispin + * Networks and Distributed Computing + * Computing & Communications + * University of Washington + * Administration Building, AG-44 + * Seattle, WA 98195 + * Internet: MRC@CAC.Washington.EDU + * + * Date: 27 July 1988 + * Last Edited: 10 September 1998 + * + * Sponsorship: The original version of this work was developed in the + * Symbolic Systems Resources Group of the Knowledge Systems + * Laboratory at Stanford University in 1987-88, and was funded + * by the Biomedical Research Technology Program of the National + * Institutes of Health under grant number RR-00785. + * + * Original version Copyright 1988 by The Leland Stanford Junior University + * Copyright 1998 by the University of Washington + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notices appear in all copies and that both the + * above copyright notices and this permission notice appear in supporting + * documentation, and that the name of the University of Washington or The + * Leland Stanford Junior University not be used in advertising or publicity + * pertaining to distribution of the software without specific, written prior + * permission. This software is made available "as is", and + * THE UNIVERSITY OF WASHINGTON AND THE LELAND STANFORD JUNIOR UNIVERSITY + * DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO THIS SOFTWARE, + * INCLUDING WITHOUT LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE, AND IN NO EVENT SHALL THE UNIVERSITY OF + * WASHINGTON OR THE LELAND STANFORD JUNIOR UNIVERSITY BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER + * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF + * CONTRACT, TORT (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef BASE64_H +#define BASE64_H + +unsigned char *_x_rfc822_binary (void *src,unsigned long srcl,unsigned long *len) XINE_PROTECTED; + +char *_x_base64_encode (const void *src, unsigned long srcl, unsigned long *len) XINE_PROTECTED; +void *_x_base64_decode (const char *src, unsigned long srcl, unsigned long *len) XINE_PROTECTED; + +#endif diff --git a/src/xine-utils/color.c b/src/xine-utils/color.c index 0b9cf0188..dc2c7e5e5 100644 --- a/src/xine-utils/color.c +++ b/src/xine-utils/color.c @@ -62,7 +62,7 @@ * instructions. */ -#include "xine_internal.h" +#include <xine/xine_internal.h> /* * In search of the perfect colorspace conversion formulae... diff --git a/src/xine-utils/compat.h b/src/xine-utils/compat.h deleted file mode 100644 index d4b95aeb3..000000000 --- a/src/xine-utils/compat.h +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (C) 2000-2001 the xine project - * - * This file is part of xine, a unix video player. - * - * xine 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. - * - * xine is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA - */ - -#ifndef XINE_COMPAT_H -#define XINE_COMPAT_H - -#include <limits.h> - -#ifdef __cplusplus -extern "C" { -#endif - -#if defined _MSC_VER -#define __XINE_FUNCTION__ __FILE__ -#elif defined __GNUC__ -#define __XINE_FUNCTION__ __FUNCTION__ -#else -#define __XINE_FUNCTION__ __func__ -#endif - -#ifndef NAME_MAX -#define XINE_NAME_MAX 256 -#else -#define XINE_NAME_MAX NAME_MAX -#endif - -#ifndef PATH_MAX -#define XINE_PATH_MAX 768 -#else -#define XINE_PATH_MAX PATH_MAX -#endif - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/src/xine-utils/copy.c b/src/xine-utils/copy.c index ed42b3a88..500b6db73 100644 --- a/src/xine-utils/copy.c +++ b/src/xine-utils/copy.c @@ -25,7 +25,7 @@ #include "config.h" #endif -#include "xineutils.h" +#include <xine/xineutils.h> void yv12_to_yv12 (const unsigned char *y_src, int y_src_pitch, unsigned char *y_dst, int y_dst_pitch, diff --git a/src/xine-utils/cpu_accel.c b/src/xine-utils/cpu_accel.c index c241dd7ef..07978b55f 100644 --- a/src/xine-utils/cpu_accel.c +++ b/src/xine-utils/cpu_accel.c @@ -24,9 +24,10 @@ #include <stdio.h> #include <stdlib.h> #include <inttypes.h> -#include <signal.h> -#include <setjmp.h> + +#if defined(HAVE_MLIB) && defined(MLIB_LAZYLOAD) #include <dlfcn.h> +#endif #if defined (__SVR4) && defined (__sun) #include <sys/systeminfo.h> @@ -38,24 +39,34 @@ #define LOG */ -#include "xineutils.h" +#include <xine/xineutils.h> -#if defined(ARCH_X86) || defined(ARCH_X86_64) +#if defined(__i386__) || defined(__x86_64__) + +#ifndef __x86_64__ +#include <signal.h> +#include <setjmp.h> static jmp_buf sigill_return; static void sigill_handler (int n) { longjmp(sigill_return, 1); } +#endif static uint32_t arch_accel (void) { uint32_t caps; -#ifdef __x86_64__ +#if defined(__x86_64__) || \ + ( defined(__SSE__) && defined(__SSE2__) && defined(__MMX__) ) /* No need to test for this on AMD64, we know what the platform has. */ - caps = MM_ACCEL_X86_MMX | MM_ACCEL_X86_SSE | MM_ACCEL_X86_MMXEXT | MM_ACCEL_X86_SSE2; + caps = MM_ACCEL_X86_MMX | MM_ACCEL_X86_SSE | MM_ACCEL_X86_MMXEXT | MM_ACCEL_X86_SSE2 +# if defined(__3dNOW__) + | MM_ACCEL_X86_3DNOW +# endif + ; #else #ifndef _MSC_VER @@ -148,6 +159,9 @@ static uint32_t arch_accel (void) caps = 0; #endif /* _MSC_VER */ +#endif /* x86_64 or built-in options */ + +#ifndef __x86_64__ /* test OS support for SSE */ if (caps & MM_ACCEL_X86_SSE) { void (*old_sigill_handler)(int); @@ -169,9 +183,12 @@ static uint32_t arch_accel (void) return caps; } -#endif /* ARCH_X86 */ +#endif /* i386 or x86_64 */ #if defined(ARCH_PPC) && defined(ENABLE_ALTIVEC) +#include <signal.h> +#include <setjmp.h> + static sigjmp_buf jmpbuf; static volatile sig_atomic_t canjump = 0; @@ -256,6 +273,9 @@ static uint32_t arch_accel (void) return flags; } #else +#include <signal.h> +#include <setjmp.h> + static sigjmp_buf jmpbuf; static volatile sig_atomic_t canjump = 0; @@ -326,7 +346,7 @@ uint32_t xine_mm_accel (void) #endif #endif -#if defined(ARCH_X86) || defined(ARCH_X86_64) || (defined(ARCH_PPC) && defined(ENABLE_ALTIVEC)) || (defined(ARCH_SPARC) && defined(ENABLE_VIS)) +#if defined(__i386__) || defined(__x86_64__) || (defined(ARCH_PPC) && defined(ENABLE_ALTIVEC)) || (defined(ARCH_SPARC) && defined(ENABLE_VIS)) accel |= arch_accel(); #endif diff --git a/src/xine-utils/crc.c b/src/xine-utils/crc.c new file mode 100644 index 000000000..4f720e9cc --- /dev/null +++ b/src/xine-utils/crc.c @@ -0,0 +1,127 @@ +/* + * Copyright (C) 2000-2007 the xine project + * + * This file is part of xine, a free video player. + * + * xine 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. + * + * xine is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA + * + * Common CRC calculation code. + */ + +#include <xine/xineutils.h> + +static const uint32_t crc32_table[256] = { + 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, + 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, + 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, + 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, + 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, + 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, + 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, + 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, + 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, + 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, + 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, + 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, + 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, + 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, + 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, + 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, + 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, + 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, + 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, + 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, + 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, + 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, + 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, + 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, + 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, + 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, + 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, + 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, + 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, + 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, + 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, + 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, + 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, + 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, + 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, + 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, + 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, + 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, + 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, + 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, + 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, + 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, + 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, + 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, + 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, + 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, + 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, + 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, + 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, + 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, + 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, + 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, + 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, + 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, + 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, + 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, + 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, + 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, + 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, + 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, + 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, + 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, + 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, + 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4 +}; + +uint32_t _x_compute_crc32 (const uint8_t *data, int32_t length, uint32_t crc32) +{ + int32_t i; + for (i = 0; i < length; ++i) + crc32 = (crc32 << 8) ^ crc32_table[(crc32 >> 24) ^ data[i]]; + return crc32; +} + +#if 0 +/* generate the CRC data */ + +#include <stdio.h> + +static void build_crc32_table (void) +{ + uint32_t i; + + for (i = 0; i < 256; ++i) + { + uint32_t j, k = 0; + for (j = (i << 24) | 0x800000; j != 0x80000000; j <<= 1) + k = (k << 1) ^ (((k ^ j) & 0x80000000) ? 0x04c11db7 : 0); + crc32_table[i] = k; + } +} + +int main (void) +{ + build_crc32_table (); + int i; + for (i = 0; i < 256; ++i) + printf ("0x%08x,%c", crc32_table[i], (3 & ~i) ? ' ' : '\n'); + return 0; +} + +#endif diff --git a/src/xine-utils/list.c b/src/xine-utils/list.c index 65bdaec26..7a2b521bd 100644 --- a/src/xine-utils/list.c +++ b/src/xine-utils/list.c @@ -23,8 +23,8 @@ #endif #include <stdlib.h> -#include "attributes.h" -#include "list.h" +#include <xine/attributes.h> +#include <xine/list.h> #define MIN_CHUNK_SIZE 32 #define MAX_CHUNK_SIZE 65536 diff --git a/src/xine-utils/list.h b/src/xine-utils/list.h deleted file mode 100644 index e00e30d6c..000000000 --- a/src/xine-utils/list.h +++ /dev/null @@ -1,104 +0,0 @@ -/* - * Copyright (C) 2000-2006 the xine project - * - * This file is part of xine, a free video player. - * - * xine 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. - * - * xine is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA - * - * Doubly-linked linked list. - * - * Exemples: - * - * Create a list: - * xine_list_t *list = xine_list_new(); - * - * Delete a list: - * xine_list_delete(list); - * - * Walk thru a list: - * xine_list_iterator_t ite = xine_list_front(list); - * while (ite) { - * _useful code here_ - * ite = xine_list_next(list, ite); - * } - * - * The list elements are managed using memory chunks and a free list. The first - * chunk contains 32 elements, each following chunk is two time as big as the - * previous one, with a limit of 64K elements. - */ -#ifndef XINE_LIST_H -#define XINE_LIST_H - -/* Doubly-linked list type */ -typedef struct xine_list_s xine_list_t; - -/* List iterator */ -typedef void* xine_list_iterator_t; - -/* Constructor */ -xine_list_t *xine_list_new(void) XINE_PROTECTED; - -/* Destructor */ -void xine_list_delete(xine_list_t *list) XINE_PROTECTED; - -/* Returns the number of element stored in the list */ -unsigned int xine_list_size(xine_list_t *list) XINE_PROTECTED; - -/* Returns true if the number of elements is zero, false otherwise */ -unsigned int xine_list_empty(xine_list_t *list) XINE_PROTECTED; - -/* Adds the element at the beginning of the list */ -void xine_list_push_front(xine_list_t *list, void *value) XINE_PROTECTED; - -/* Adds the element at the end of the list */ -void xine_list_push_back(xine_list_t *list, void *value) XINE_PROTECTED; - -/* Remove all elements from a list */ -void xine_list_clear(xine_list_t *list) XINE_PROTECTED; - -/* Insert the element elem into the list at the position specified by the - iterator (before the element, if any, that was previously at the iterator's - position). The return value is an iterator that specifies the position of - the inserted element. */ -xine_list_iterator_t xine_list_insert(xine_list_t *list, - xine_list_iterator_t position, - void *value) XINE_PROTECTED; - -/* Remove one element from a list.*/ -void xine_list_remove(xine_list_t *list, xine_list_iterator_t position) XINE_PROTECTED; - -/* Returns an iterator that references the first element of the list */ -xine_list_iterator_t xine_list_front(xine_list_t *list) XINE_PROTECTED; - -/* Returns an iterator that references the last element of the list */ -xine_list_iterator_t xine_list_back(xine_list_t *list) XINE_PROTECTED; - -/* Perform a linear search of a given value, and returns an iterator that - references this value or NULL if not found */ -xine_list_iterator_t xine_list_find(xine_list_t *list, void *value) XINE_PROTECTED; - -/* Increments the iterator's value, so it specifies the next element in the list - or NULL at the end of the list */ -xine_list_iterator_t xine_list_next(xine_list_t *list, xine_list_iterator_t ite) XINE_PROTECTED; - -/* Increments the iterator's value, so it specifies the previous element in the list - or NULL at the beginning of the list */ -xine_list_iterator_t xine_list_prev(xine_list_t *list, xine_list_iterator_t ite) XINE_PROTECTED; - -/* Returns the value at the position specified by the iterator */ -void *xine_list_get_value(xine_list_t *list, xine_list_iterator_t ite) XINE_PROTECTED; - -#endif - diff --git a/src/xine-utils/memcpy.c b/src/xine-utils/memcpy.c index 1b3e38fd1..45009d23c 100644 --- a/src/xine-utils/memcpy.c +++ b/src/xine-utils/memcpy.c @@ -50,7 +50,7 @@ #define LOG */ -#include "xine_internal.h" +#include <xine/xine_internal.h> void *(* xine_fast_memcpy)(void *to, const void *from, size_t len); @@ -382,30 +382,29 @@ static void *linux_kernel_memcpy(void *to, const void *from, size_t len) { #endif /* _MSC_VER */ #endif /* ARCH_X86 */ -static struct { - char *name; - void *(* function)(void *to, const void *from, size_t len); - - uint64_t time; /* This type could be used for non-MSC build too! */ +static const struct { + const char name[16]; + void *(*const function)(void *to, const void *from, size_t len); uint32_t cpu_require; } memcpy_method[] = { - { NULL, NULL, 0, 0 }, - { "libc memcpy()", memcpy, 0, 0 }, + { "", NULL, 0 }, + { "libc", memcpy, 0 }, #if (defined(ARCH_X86) || defined(ARCH_X86_64)) && !defined(_MSC_VER) - { "linux kernel memcpy()", linux_kernel_memcpy, 0, 0 }, - { "MMX optimized memcpy()", mmx_memcpy, 0, MM_MMX }, - { "MMXEXT optimized memcpy()", mmx2_memcpy, 0, MM_MMXEXT }, - { "SSE optimized memcpy()", sse_memcpy, 0, MM_MMXEXT|MM_SSE }, + { "linux kernel", linux_kernel_memcpy, 0 }, + { "MMX ", mmx_memcpy, MM_MMX }, + { "MMXEXT", mmx2_memcpy, MM_MMXEXT }, + { "SSE", sse_memcpy, MM_MMXEXT|MM_SSE }, #endif /* ARCH_X86 */ #if defined (ARCH_PPC) && !defined (HOST_OS_DARWIN) - { "ppcasm_memcpy()", ppcasm_memcpy, 0, 0 }, - { "ppcasm_cacheable_memcpy()", ppcasm_cacheable_memcpy, 0, MM_ACCEL_PPC_CACHE32 }, + { "ppcasm", ppcasm_memcpy, 0 }, + { "ppcasm_cached", ppcasm_cacheable_memcpy, MM_ACCEL_PPC_CACHE32 }, #endif /* ARCH_PPC && !HOST_OS_DARWIN */ - { NULL, NULL, 0, 0 } }; +static uint64_t memcpy_timing[sizeof(memcpy_method)/sizeof(memcpy_method[0])] = { 0, }; + #if (defined(ARCH_X86) || defined(ARCH_X86_64)) && defined(HAVE_SYS_TIMES_H) static int64_t rdtsc(int config_flags) { @@ -446,7 +445,7 @@ static void update_fast_memcpy(void *user_data, xine_cfg_entry_t *entry) { if (method != 0 && (config_flags & memcpy_method[method].cpu_require) == memcpy_method[method].cpu_require ) { - lprintf("using %s\n", memcpy_method[method].name ); + lprintf("using %s memcpy()\n", memcpy_method[method].name ); xine_fast_memcpy = memcpy_method[method].function; return; } else { @@ -461,7 +460,7 @@ void xine_probe_fast_memcpy(xine_t *xine) char *buf1, *buf2; int i, j, best; int config_flags = -1; - static const char *memcpy_methods[] = { + static const char *const memcpy_methods[] = { "probe", "libc", #if (defined(ARCH_X86) || defined(ARCH_X86_64)) && !defined(_MSC_VER) "kernel", "mmx", "mmxext", "sse", @@ -487,7 +486,7 @@ void xine_probe_fast_memcpy(xine_t *xine) if( best != 0 && (config_flags & memcpy_method[best].cpu_require) == memcpy_method[best].cpu_require ) { - lprintf("using %s\n", memcpy_method[best].name ); + lprintf("using %s memcpy()\n", memcpy_method[best].name ); xine_fast_memcpy = memcpy_method[best].function; return; } @@ -509,7 +508,7 @@ void xine_probe_fast_memcpy(xine_t *xine) memset(buf1,0,BUFSIZE); memset(buf2,0,BUFSIZE); - for(i=1; memcpy_method[i].name; i++) + for(i = 1; i < sizeof(memcpy_method)/sizeof(memcpy_method[0]); i++) { if( (config_flags & memcpy_method[i].cpu_require) != memcpy_method[i].cpu_require ) @@ -522,11 +521,11 @@ void xine_probe_fast_memcpy(xine_t *xine) } t = rdtsc(config_flags) - t; - memcpy_method[i].time = t; + memcpy_timing[i] = t; - xprintf(xine, XINE_VERBOSITY_LOG, "\t%s : %" PRIu64 "\n", memcpy_method[i].name, t); + xprintf(xine, XINE_VERBOSITY_LOG, "\t%s memcpy() : %" PRIu64 "\n", memcpy_method[i].name, t); - if( best == 0 || t < memcpy_method[best].time ) + if( best == 0 || t < memcpy_timing[best] ) best = i; } diff --git a/src/xine-utils/monitor.c b/src/xine-utils/monitor.c index fb323055c..8cbfdaa72 100644 --- a/src/xine-utils/monitor.c +++ b/src/xine-utils/monitor.c @@ -26,7 +26,7 @@ #include <stdio.h> #include <sys/time.h> -#include "xineutils.h" +#include <xine/xineutils.h> #define MAX_ID 10 @@ -38,13 +38,10 @@ static long profiler_calls[MAX_ID] ; static const char *profiler_label[MAX_ID] ; void xine_profiler_init () { - int i; - for (i=0; i<MAX_ID; i++) { - profiler_times[i] = 0; - profiler_start[i] = 0; - profiler_calls[i] = 0; - profiler_label[i] = NULL; - } + memset(profiler_times, 0, sizeof(profiler_times)); + memset(profiler_start, 0, sizeof(profiler_start)); + memset(profiler_calls, 0, sizeof(profiler_calls)); + memset(profiler_label, 0, sizeof(profiler_label)); } int xine_profiler_allocate_slot (const char *label) { diff --git a/src/xine-utils/pool.c b/src/xine-utils/pool.c index a1fddadd9..60330ef53 100644 --- a/src/xine-utils/pool.c +++ b/src/xine-utils/pool.c @@ -22,9 +22,9 @@ #endif #include <assert.h> -#include "attributes.h" -#include "pool.h" -#include "array.h" +#include <xine/attributes.h> +#include <xine/pool.h> +#include <xine/array.h> #define MIN_CHUNK_SIZE 32 #define MAX_CHUNK_SIZE 65536 diff --git a/src/xine-utils/pool.h b/src/xine-utils/pool.h deleted file mode 100644 index 918da82a2..000000000 --- a/src/xine-utils/pool.h +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright (C) 2000-2006 the xine project - * - * This file is part of xine, a free video player. - * - * xine 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. - * - * xine is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA - * - * Object Pool - */ - -#include <stdlib.h> -#include <inttypes.h> - -typedef struct xine_pool_s xine_pool_t; - -/* Creates a new pool - * object_size: sizeof(your struct) - * create_object: function called to create an object (can be NULL) - * prepare_object: function called to prepare an object to returned to the client (can be NULL) - * return_object: function called to prepare an object to returned to the pool (can be NULL) - * delete_object: function called to delete an object (can be NULL) - */ -xine_pool_t *xine_pool_new(size_t object_size, - void (create_object)(void *object), - void (prepare_object)(void *object), - void (return_object)(void *object), - void (delete_object)(void *object)) XINE_PROTECTED; - -/* Deletes a pool */ -void xine_pool_delete(xine_pool_t *pool) XINE_PROTECTED; - -/* Get an object from the pool */ -void *xine_pool_get(xine_pool_t *pool) XINE_PROTECTED; - -/* Returns an object to the pool */ -void xine_pool_put(xine_pool_t *pool, void *object) XINE_PROTECTED; diff --git a/src/xine-utils/ring_buffer.c b/src/xine-utils/ring_buffer.c index 031fda4fc..7042eaa68 100644 --- a/src/xine-utils/ring_buffer.c +++ b/src/xine-utils/ring_buffer.c @@ -27,10 +27,10 @@ #include <assert.h> #include <stdio.h> #include <string.h> -#include "attributes.h" -#include "pool.h" -#include "list.h" -#include "ring_buffer.h" +#include <xine/attributes.h> +#include <xine/pool.h> +#include <xine/list.h> +#include <xine/ring_buffer.h> #define RING_BUFFER_EXTRA_BUFFER_SIZE (1024 * 8) diff --git a/src/xine-utils/ring_buffer.h b/src/xine-utils/ring_buffer.h deleted file mode 100644 index efcffd3b7..000000000 --- a/src/xine-utils/ring_buffer.h +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (C) 2000-2006 the xine project - * - * This file is part of xine, a free video player. - * - * xine 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. - * - * xine is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA - * - * Fifo + Ring Buffer - */ -typedef struct xine_ring_buffer_s xine_ring_buffer_t; - -/* Creates a new ring buffer */ -xine_ring_buffer_t *xine_ring_buffer_new(size_t size) XINE_PROTECTED; - -/* Deletes a ring buffer */ -void xine_ring_buffer_delete(xine_ring_buffer_t *ring_buffer) XINE_PROTECTED; - -/* Returns a new chunk of the specified size */ -/* Might block if the ring buffer is full */ -void *xine_ring_buffer_alloc(xine_ring_buffer_t *ring_buffer, size_t size) XINE_PROTECTED; - -/* Put a chunk into the ring */ -void xine_ring_buffer_put(xine_ring_buffer_t *ring_buffer, void *chunk) XINE_PROTECTED; - -/* Get a chunk of a specified size from the ring buffer - * Might block if the ring buffer is empty - * param size: the desired size - * param rsize: the size of the chunk returned - * rsize is not equal to size at the end of stream, the caller MUST check - * rsize value. - */ -void *xine_ring_buffer_get(xine_ring_buffer_t *ring_buffer, size_t size, size_t *rsize) XINE_PROTECTED; - -/* Releases the chunk, makes memory available for the alloc function */ -void xine_ring_buffer_release(xine_ring_buffer_t *ring_buffer, void *chunk) XINE_PROTECTED; - -/* Closes the ring buffer - * The writer uses this function to signal the end of stream to the reader. - * The reader MUST check the rsize value returned by the get function. - */ -void xine_ring_buffer_close(xine_ring_buffer_t *ring_buffer) XINE_PROTECTED; - - diff --git a/src/xine-utils/sorted_array.c b/src/xine-utils/sorted_array.c index 363325f0b..9dbe1fd0e 100644 --- a/src/xine-utils/sorted_array.c +++ b/src/xine-utils/sorted_array.c @@ -23,8 +23,8 @@ #include <stdlib.h> #include <string.h> -#include "attributes.h" -#include "sorted_array.h" +#include <xine/attributes.h> +#include <xine/sorted_array.h> /* Array internal struct */ struct xine_sarray_s { diff --git a/src/xine-utils/sorted_array.h b/src/xine-utils/sorted_array.h deleted file mode 100644 index a1894eca3..000000000 --- a/src/xine-utils/sorted_array.h +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (C) 2000-2006 the xine project - * - * This file is part of xine, a free video player. - * - * xine 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. - * - * xine is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA - * - * Sorted array which grows automatically when you add elements. - * A binary search is used to find the position of a new element. - * - * Example: - * Let's create de comparison method for integers: - * - * int int_comparator(void *a, void *b) { - * if ((int)a < (int)b) { - * return -1; - * } else if ((int)a == (int)b) { - * return 0; - * } else { - * return 1; - * } - * } - * - * Create a sorted array for integers: - * xine_sarray_t *sarray = xine_sarray_new(10, int_comparator); - * - * Add elements: - * xine_sarray_add(sarray, (void*)4); - * xine_sarray_add(sarray, (void*)28); - * xine_sarray_add(sarray, (void*)7); - * - * Find an element: - * int pos = xine_sarray_binary_search(sarray, (void*)7); - * if (pos >= 0) - * FOUND - * else - * NOT FOUND - * - * Delete the array: - * xine_sarray_delete(sarray); - */ -#ifndef XINE_SORTED_ARRAY_H -#define XINE_SORTED_ARRAY_H - -#include "array.h" - -/* Array type */ -typedef struct xine_sarray_s xine_sarray_t; - -/* Array element comparator */ -typedef int (*xine_sarray_comparator_t)(void*, void*); - -/* Constructor */ -xine_sarray_t *xine_sarray_new(size_t initial_size, xine_sarray_comparator_t comparator) XINE_PROTECTED; - -/* Destructor */ -void xine_sarray_delete(xine_sarray_t *sarray) XINE_PROTECTED; - -/* Returns the number of element stored in the array */ -size_t xine_sarray_size(const xine_sarray_t *sarray) XINE_PROTECTED; - -/* Removes all elements from an array */ -void xine_sarray_clear(xine_sarray_t *sarray) XINE_PROTECTED; - -/* Adds the element into the array - Returns the insertion position */ -int xine_sarray_add(xine_sarray_t *sarray, void *value) XINE_PROTECTED; - -/* Removes one element from an array at the position specified */ -void xine_sarray_remove(xine_sarray_t *sarray, unsigned int position) XINE_PROTECTED; - -/* Get the element at the position specified */ -void *xine_sarray_get(xine_sarray_t *sarray, unsigned int position) XINE_PROTECTED; - -/* Returns the index of the search key, if it is contained in the list. - Otherwise, (-(insertion point) - 1) or ~(insertion point). - The insertion point is defined as the point at which the key would be - inserted into the array. */ -int xine_sarray_binary_search(xine_sarray_t *sarray, void *key) XINE_PROTECTED; - -#endif - diff --git a/src/xine-utils/utils.c b/src/xine-utils/utils.c index cc3ffdc2c..c414f481f 100644 --- a/src/xine-utils/utils.c +++ b/src/xine-utils/utils.c @@ -27,10 +27,10 @@ #include "config.h" #endif -#include "xineutils.h" -#include "xineintl.h" +#include <xine/xineutils.h> +#include <xine/xineintl.h> #ifdef _MSC_VER -#include "xine_internal.h" +#include <xine/xine_internal.h> #endif #include <errno.h> @@ -57,10 +57,10 @@ #endif typedef struct { - char *language; /* name of the locale */ - char *encoding; /* typical encoding */ - char *spu_encoding; /* default spu encoding */ - char *modifier; + const char language[16]; /* name of the locale */ + const char encoding[16]; /* typical encoding */ + const char spu_encoding[16]; /* default spu encoding */ + const char modifier[8]; } lang_locale_t; @@ -68,172 +68,172 @@ typedef struct { * information about locales used in xine */ static const lang_locale_t lang_locales[] = { - { "af_ZA", "iso-8859-1", "iso-8859-1", NULL }, - { "ar_AE", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_BH", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_DZ", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_EG", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_IN", "utf-8", "utf-8", NULL }, - { "ar_IQ", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_JO", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_KW", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_LB", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_LY", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_MA", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_OM", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_QA", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_SA", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_SD", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_SY", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_TN", "iso-8859-6", "iso-8859-6", NULL }, - { "ar_YE", "iso-8859-6", "iso-8859-6", NULL }, - { "be_BY", "cp1251", "cp1251", NULL }, - { "bg_BG", "cp1251", "cp1251", NULL }, - { "br_FR", "iso-8859-1", "iso-88591", NULL }, - { "bs_BA", "iso-8859-2", "cp1250", NULL }, - { "ca_ES", "iso-8859-1", "iso-88591", NULL }, + { "af_ZA", "iso-8859-1", "iso-8859-1", "" }, + { "ar_AE", "iso-8859-6", "iso-8859-6", "" }, + { "ar_BH", "iso-8859-6", "iso-8859-6", "" }, + { "ar_DZ", "iso-8859-6", "iso-8859-6", "" }, + { "ar_EG", "iso-8859-6", "iso-8859-6", "" }, + { "ar_IN", "utf-8", "utf-8", "" }, + { "ar_IQ", "iso-8859-6", "iso-8859-6", "" }, + { "ar_JO", "iso-8859-6", "iso-8859-6", "" }, + { "ar_KW", "iso-8859-6", "iso-8859-6", "" }, + { "ar_LB", "iso-8859-6", "iso-8859-6", "" }, + { "ar_LY", "iso-8859-6", "iso-8859-6", "" }, + { "ar_MA", "iso-8859-6", "iso-8859-6", "" }, + { "ar_OM", "iso-8859-6", "iso-8859-6", "" }, + { "ar_QA", "iso-8859-6", "iso-8859-6", "" }, + { "ar_SA", "iso-8859-6", "iso-8859-6", "" }, + { "ar_SD", "iso-8859-6", "iso-8859-6", "" }, + { "ar_SY", "iso-8859-6", "iso-8859-6", "" }, + { "ar_TN", "iso-8859-6", "iso-8859-6", "" }, + { "ar_YE", "iso-8859-6", "iso-8859-6", "" }, + { "be_BY", "cp1251", "cp1251", "" }, + { "bg_BG", "cp1251", "cp1251", "" }, + { "br_FR", "iso-8859-1", "iso-88591", "" }, + { "bs_BA", "iso-8859-2", "cp1250", "" }, + { "ca_ES", "iso-8859-1", "iso-88591", "" }, { "ca_ES", "iso-8859-15", "iso-8859-15", "euro" }, - { "cs_CZ", "iso-8859-2", "cp1250", NULL }, - { "cy_GB", "iso-8859-14", "iso-8859-14", NULL }, - { "da_DK", "iso-8859-1", "iso-8859-1", NULL }, - { "de_AT", "iso-8859-1", "iso-8859-1", NULL }, + { "cs_CZ", "iso-8859-2", "cp1250", "" }, + { "cy_GB", "iso-8859-14", "iso-8859-14", "" }, + { "da_DK", "iso-8859-1", "iso-8859-1", "" }, + { "de_AT", "iso-8859-1", "iso-8859-1", "" }, { "de_AT", "iso-8859-15", "iso-8859-15", "euro" }, - { "de_BE", "iso-8859-1", "iso-8859-1", NULL }, + { "de_BE", "iso-8859-1", "iso-8859-1", "" }, { "de_BE", "iso-8859-15", "iso-8859-15", "euro" }, - { "de_CH", "iso-8859-1", "iso-8859-1", NULL }, - { "de_DE", "iso-8859-1", "iso-8859-1", NULL }, + { "de_CH", "iso-8859-1", "iso-8859-1", "" }, + { "de_DE", "iso-8859-1", "iso-8859-1", "" }, { "de_DE", "iso-8859-15", "iso-8859-15", "euro" }, - { "de_LU", "iso-8859-1", "iso-8859-1", NULL }, + { "de_LU", "iso-8859-1", "iso-8859-1", "" }, { "de_LU", "iso-8859-15", "iso-8859-15", "euro" }, - { "el_GR", "iso-8859-7", "iso-8859-7", NULL }, - { "en_AU", "iso-8859-1", "iso-8859-1", NULL }, - { "en_BW", "iso-8859-1", "iso-8859-1", NULL }, - { "en_CA", "iso-8859-1", "iso-8859-1", NULL }, - { "en_DK", "iso-8859-1", "iso-8859-1", NULL }, - { "en_GB", "iso-8859-1", "iso-8859-1", NULL }, - { "en_HK", "iso-8859-1", "iso-8859-1", NULL }, - { "en_IE", "iso-8859-1", "iso-8859-1", NULL }, + { "el_GR", "iso-8859-7", "iso-8859-7", "" }, + { "en_AU", "iso-8859-1", "iso-8859-1", "" }, + { "en_BW", "iso-8859-1", "iso-8859-1", "" }, + { "en_CA", "iso-8859-1", "iso-8859-1", "" }, + { "en_DK", "iso-8859-1", "iso-8859-1", "" }, + { "en_GB", "iso-8859-1", "iso-8859-1", "" }, + { "en_HK", "iso-8859-1", "iso-8859-1", "" }, + { "en_IE", "iso-8859-1", "iso-8859-1", "" }, { "en_IE", "iso-8859-15", "iso-8859-15", "euro" }, - { "en_IN", "utf-8", "utf-8", NULL }, - { "en_NZ", "iso-8859-1", "iso-8859-1", NULL }, - { "en_PH", "iso-8859-1", "iso-8859-1", NULL }, - { "en_SG", "iso-8859-1", "iso-8859-1", NULL }, - { "en_US", "iso-8859-1", "iso-8859-1", NULL }, - { "en_ZA", "iso-8859-1", "iso-8859-1", NULL }, - { "en_ZW", "iso-8859-1", "iso-8859-1", NULL }, - { "es_AR", "iso-8859-1", "iso-8859-1", NULL }, - { "es_BO", "iso-8859-1", "iso-8859-1", NULL }, - { "es_CL", "iso-8859-1", "iso-8859-1", NULL }, - { "es_CO", "iso-8859-1", "iso-8859-1", NULL }, - { "es_CR", "iso-8859-1", "iso-8859-1", NULL }, - { "es_DO", "iso-8859-1", "iso-8859-1", NULL }, - { "es_EC", "iso-8859-1", "iso-8859-1", NULL }, - { "es_ES", "iso-8859-1", "iso-8859-1", NULL }, + { "en_IN", "utf-8", "utf-8", "" }, + { "en_NZ", "iso-8859-1", "iso-8859-1", "" }, + { "en_PH", "iso-8859-1", "iso-8859-1", "" }, + { "en_SG", "iso-8859-1", "iso-8859-1", "" }, + { "en_US", "iso-8859-1", "iso-8859-1", "" }, + { "en_ZA", "iso-8859-1", "iso-8859-1", "" }, + { "en_ZW", "iso-8859-1", "iso-8859-1", "" }, + { "es_AR", "iso-8859-1", "iso-8859-1", "" }, + { "es_BO", "iso-8859-1", "iso-8859-1", "" }, + { "es_CL", "iso-8859-1", "iso-8859-1", "" }, + { "es_CO", "iso-8859-1", "iso-8859-1", "" }, + { "es_CR", "iso-8859-1", "iso-8859-1", "" }, + { "es_DO", "iso-8859-1", "iso-8859-1", "" }, + { "es_EC", "iso-8859-1", "iso-8859-1", "" }, + { "es_ES", "iso-8859-1", "iso-8859-1", "" }, { "es_ES", "iso-8859-15", "iso-8859-15", "euro" }, - { "es_GT", "iso-8859-1", "iso-8859-1", NULL }, - { "es_HN", "iso-8859-1", "iso-8859-1", NULL }, - { "es_MX", "iso-8859-1", "iso-8859-1", NULL }, - { "es_NI", "iso-8859-1", "iso-8859-1", NULL }, - { "es_PA", "iso-8859-1", "iso-8859-1", NULL }, - { "es_PE", "iso-8859-1", "iso-8859-1", NULL }, - { "es_PR", "iso-8859-1", "iso-8859-1", NULL }, - { "es_PY", "iso-8859-1", "iso-8859-1", NULL }, - { "es_SV", "iso-8859-1", "iso-8859-1", NULL }, - { "es_US", "iso-8859-1", "iso-8859-1", NULL }, - { "es_UY", "iso-8859-1", "iso-8859-1", NULL }, - { "es_VE", "iso-8859-1", "iso-8859-1", NULL }, - { "et_EE", "iso-8859-1", "iso-8859-1", NULL }, - { "eu_ES", "iso-8859-1", "iso-8859-1", NULL }, + { "es_GT", "iso-8859-1", "iso-8859-1", "" }, + { "es_HN", "iso-8859-1", "iso-8859-1", "" }, + { "es_MX", "iso-8859-1", "iso-8859-1", "" }, + { "es_NI", "iso-8859-1", "iso-8859-1", "" }, + { "es_PA", "iso-8859-1", "iso-8859-1", "" }, + { "es_PE", "iso-8859-1", "iso-8859-1", "" }, + { "es_PR", "iso-8859-1", "iso-8859-1", "" }, + { "es_PY", "iso-8859-1", "iso-8859-1", "" }, + { "es_SV", "iso-8859-1", "iso-8859-1", "" }, + { "es_US", "iso-8859-1", "iso-8859-1", "" }, + { "es_UY", "iso-8859-1", "iso-8859-1", "" }, + { "es_VE", "iso-8859-1", "iso-8859-1", "" }, + { "et_EE", "iso-8859-1", "iso-8859-1", "" }, + { "eu_ES", "iso-8859-1", "iso-8859-1", "" }, { "eu_ES", "iso-8859-15", "iso-8859-15", "euro" }, - { "fa_IR", "utf-8", "utf-8", NULL }, - { "fi_FI", "iso-8859-1", "iso-8859-1", NULL }, + { "fa_IR", "utf-8", "utf-8", "" }, + { "fi_FI", "iso-8859-1", "iso-8859-1", "" }, { "fi_FI", "iso-8859-15", "iso-8859-15", "euro" }, - { "fo_FO", "iso-8859-1", "iso-8859-1", NULL }, - { "fr_BE", "iso-8859-1", "iso-8859-1", NULL }, + { "fo_FO", "iso-8859-1", "iso-8859-1", "" }, + { "fr_BE", "iso-8859-1", "iso-8859-1", "" }, { "fr_BE", "iso-8859-15", "iso-8859-15", "euro" }, - { "fr_CA", "iso-8859-1", "iso-8859-1", NULL }, - { "fr_CH", "iso-8859-1", "iso-8859-1", NULL }, - { "fr_FR", "iso-8859-1", "iso-8859-1", NULL }, + { "fr_CA", "iso-8859-1", "iso-8859-1", "" }, + { "fr_CH", "iso-8859-1", "iso-8859-1", "" }, + { "fr_FR", "iso-8859-1", "iso-8859-1", "" }, { "fr_FR", "iso-8859-15", "iso-8859-15", "euro" }, - { "fr_LU", "iso-8859-1", "iso-8859-1", NULL }, + { "fr_LU", "iso-8859-1", "iso-8859-1", "" }, { "fr_LU", "iso-8859-15", "iso-8859-15", "euro" }, - { "ga_IE", "iso-8859-1", "iso-8859-1", NULL }, + { "ga_IE", "iso-8859-1", "iso-8859-1", "" }, { "ga_IE", "iso-8859-15", "iso-8859-15", "euro" }, - { "gl_ES", "iso-8859-1", "iso-8859-1", NULL }, + { "gl_ES", "iso-8859-1", "iso-8859-1", "" }, { "gl_ES", "iso-8859-15", "iso-8859-15", "euro" }, - { "gv_GB", "iso-8859-1", "iso-8859-1", NULL }, - { "he_IL", "iso-8859-8", "iso-8859-8", NULL }, - { "hi_IN", "utf-8", "utf-8", NULL }, - { "hr_HR", "iso-8859-2", "cp1250", NULL }, - { "hu_HU", "iso-8859-2", "cp1250", NULL }, - { "id_ID", "iso-8859-1", "iso-8859-1", NULL }, - { "is_IS", "iso-8859-1", "iso-8859-1", NULL }, - { "it_CH", "iso-8859-1", "iso-8859-1", NULL }, - { "it_IT", "iso-8859-1", "iso-8859-1", NULL }, + { "gv_GB", "iso-8859-1", "iso-8859-1", "" }, + { "he_IL", "iso-8859-8", "iso-8859-8", "" }, + { "hi_IN", "utf-8", "utf-8", "" }, + { "hr_HR", "iso-8859-2", "cp1250", "" }, + { "hu_HU", "iso-8859-2", "cp1250", "" }, + { "id_ID", "iso-8859-1", "iso-8859-1", "" }, + { "is_IS", "iso-8859-1", "iso-8859-1", "" }, + { "it_CH", "iso-8859-1", "iso-8859-1", "" }, + { "it_IT", "iso-8859-1", "iso-8859-1", "" }, { "it_IT", "iso-8859-15", "iso-8859-15", "euro" }, - { "iw_IL", "iso-8859-8", "iso-8859-8", NULL }, - { "ja_JP", "euc-jp", "euc-jp", NULL }, - { "ja_JP", "ujis", "ujis", NULL }, - { "japanese", "euc", "euc", NULL }, - { "ka_GE", "georgian-ps", "georgian-ps", NULL }, - { "kl_GL", "iso-8859-1", "iso-8859-1", NULL }, - { "ko_KR", "euc-kr", "euc-kr", NULL }, - { "ko_KR", "utf-8", "utf-8", NULL }, - { "korean", "euc", "euc", NULL }, - { "kw_GB", "iso-8859-1", "iso-8859-1", NULL }, - { "lt_LT", "iso-8859-13", "iso-8859-13", NULL }, - { "lv_LV", "iso-8859-13", "iso-8859-13", NULL }, - { "mi_NZ", "iso-8859-13", "iso-8859-13", NULL }, - { "mk_MK", "iso-8859-5", "cp1251", NULL }, - { "mr_IN", "utf-8", "utf-8", NULL }, - { "ms_MY", "iso-8859-1", "iso-8859-1", NULL }, - { "mt_MT", "iso-8859-3", "iso-8859-3", NULL }, - { "nb_NO", "ISO-8859-1", "ISO-8859-1", NULL }, - { "nl_BE", "iso-8859-1", "iso-8859-1", NULL }, + { "iw_IL", "iso-8859-8", "iso-8859-8", "" }, + { "ja_JP", "euc-jp", "euc-jp", "" }, + { "ja_JP", "ujis", "ujis", "" }, + { "japanese", "euc", "euc", "" }, + { "ka_GE", "georgian-ps", "georgian-ps", "" }, + { "kl_GL", "iso-8859-1", "iso-8859-1", "" }, + { "ko_KR", "euc-kr", "euc-kr", "" }, + { "ko_KR", "utf-8", "utf-8", "" }, + { "korean", "euc", "euc", "" }, + { "kw_GB", "iso-8859-1", "iso-8859-1", "" }, + { "lt_LT", "iso-8859-13", "iso-8859-13", "" }, + { "lv_LV", "iso-8859-13", "iso-8859-13", "" }, + { "mi_NZ", "iso-8859-13", "iso-8859-13", "" }, + { "mk_MK", "iso-8859-5", "cp1251", "" }, + { "mr_IN", "utf-8", "utf-8", "" }, + { "ms_MY", "iso-8859-1", "iso-8859-1", "" }, + { "mt_MT", "iso-8859-3", "iso-8859-3", "" }, + { "nb_NO", "ISO-8859-1", "ISO-8859-1", "" }, + { "nl_BE", "iso-8859-1", "iso-8859-1", "" }, { "nl_BE", "iso-8859-15", "iso-8859-15", "euro" }, - { "nl_NL", "iso-8859-1", "iso-8859-1", NULL }, + { "nl_NL", "iso-8859-1", "iso-8859-1", "" }, { "nl_NL", "iso-8859-15", "iso-8859-15", "euro" }, - { "nn_NO", "iso-8859-1", "iso-8859-1", NULL }, - { "no_NO", "iso-8859-1", "iso-8859-1", NULL }, - { "oc_FR", "iso-8859-1", "iso-8859-1", NULL }, - { "pl_PL", "iso-8859-2", "cp1250", NULL }, - { "pt_BR", "iso-8859-1", "iso-8859-1", NULL }, - { "pt_PT", "iso-8859-1", "iso-8859-1", NULL }, + { "nn_NO", "iso-8859-1", "iso-8859-1", "" }, + { "no_NO", "iso-8859-1", "iso-8859-1", "" }, + { "oc_FR", "iso-8859-1", "iso-8859-1", "" }, + { "pl_PL", "iso-8859-2", "cp1250", "" }, + { "pt_BR", "iso-8859-1", "iso-8859-1", "" }, + { "pt_PT", "iso-8859-1", "iso-8859-1", "" }, { "pt_PT", "iso-8859-15", "iso-8859-15", "euro" }, - { "ro_RO", "iso-8859-2", "cp1250", NULL }, - { "ru_RU", "iso-8859-5", "cp1251", NULL }, - { "ru_RU", "koi8-r", "cp1251", NULL }, - { "ru_UA", "koi8-u", "cp1251", NULL }, - { "se_NO", "utf-8", "utf-8", NULL }, - { "sk_SK", "iso-8859-2", "cp1250", NULL }, - { "sl_SI", "iso-8859-2", "cp1250", NULL }, - { "sq_AL", "iso-8859-1", "iso-8859-1", NULL }, - { "sr_YU", "iso-8859-2", "cp1250", NULL }, + { "ro_RO", "iso-8859-2", "cp1250", "" }, + { "ru_RU", "iso-8859-5", "cp1251", "" }, + { "ru_RU", "koi8-r", "cp1251", "" }, + { "ru_UA", "koi8-u", "cp1251", "" }, + { "se_NO", "utf-8", "utf-8", "" }, + { "sk_SK", "iso-8859-2", "cp1250", "" }, + { "sl_SI", "iso-8859-2", "cp1250", "" }, + { "sq_AL", "iso-8859-1", "iso-8859-1", "" }, + { "sr_YU", "iso-8859-2", "cp1250", "" }, { "sr_YU", "iso-8859-5", "cp1251", "cyrillic" }, - { "sv_FI", "iso-8859-1", "iso-8859-1", NULL }, + { "sv_FI", "iso-8859-1", "iso-8859-1", "" }, { "sv_FI", "iso-8859-15", "iso-8859-15", "euro" }, - { "sv_SE", "iso-8859-1", "iso-8859-1", NULL }, - { "ta_IN", "utf-8", "utf-8", NULL }, - { "te_IN", "utf-8", "utf-8", NULL }, - { "tg_TJ", "koi8-t", "cp1251", NULL }, - { "th_TH", "tis-620", "tis-620", NULL }, - { "tl_PH", "iso-8859-1", "iso-8859-1", NULL }, - { "tr_TR", "iso-8859-9", "iso-8859-9", NULL }, - { "uk_UA", "koi8-u", "cp1251", NULL }, - { "ur_PK", "utf-8", "utf-8", NULL }, - { "uz_UZ", "iso-8859-1", "iso-8859-1", NULL }, - { "vi_VN", "tcvn", "tcvn", NULL }, - { "vi_VN", "utf-8", "utf-8", NULL }, - { "wa_BE", "iso-8859-1", "iso-8859-1", NULL }, + { "sv_SE", "iso-8859-1", "iso-8859-1", "" }, + { "ta_IN", "utf-8", "utf-8", "" }, + { "te_IN", "utf-8", "utf-8", "" }, + { "tg_TJ", "koi8-t", "cp1251", "" }, + { "th_TH", "tis-620", "tis-620", "" }, + { "tl_PH", "iso-8859-1", "iso-8859-1", "" }, + { "tr_TR", "iso-8859-9", "iso-8859-9", "" }, + { "uk_UA", "koi8-u", "cp1251", "" }, + { "ur_PK", "utf-8", "utf-8", "" }, + { "uz_UZ", "iso-8859-1", "iso-8859-1", "" }, + { "vi_VN", "tcvn", "tcvn", "" }, + { "vi_VN", "utf-8", "utf-8", "" }, + { "wa_BE", "iso-8859-1", "iso-8859-1", "" }, { "wa_BE", "iso-8859-15", "iso-8859-15", "euro" }, - { "yi_US", "cp1255", "cp1255", NULL }, - { "zh_CN", "gb18030", "gb18030", NULL }, - { "zh_CN", "gb2312", "gb2312", NULL }, - { "zh_CN", "gbk", "gbk", NULL }, - { "zh_HK", "big5-hkscs", "big5-hkscs", NULL }, - { "zh_TW", "big-5", "big-5", NULL }, - { "zh_TW", "euc-tw", "euc-tw", NULL }, - { NULL, NULL, NULL, NULL } + { "yi_US", "cp1255", "cp1255", "" }, + { "zh_CN", "gb18030", "gb18030", "" }, + { "zh_CN", "gb2312", "gb2312", "" }, + { "zh_CN", "gbk", "gbk", "" }, + { "zh_HK", "big5-hkscs", "big5-hkscs", "" }, + { "zh_TW", "big-5", "big-5", "" }, + { "zh_TW", "euc-tw", "euc-tw", "" }, + { "" } }; @@ -253,6 +253,27 @@ void *xine_xmalloc(size_t size) { return ptr; } +/** + * @brief Wrapper around calloc() function. + * @param nmemb Number of elements to allocate + * @param size Size of each element to allocate + * + * This is a simple wrapper around calloc(), the only thing + * it does more than calloc() is outputting an error if + * the calloc fails (returning NULL). + */ +void *xine_xcalloc(size_t nmemb, size_t size) { + void *ptr; + + if((ptr = calloc(nmemb, size)) == NULL) { + fprintf(stderr, "%s: calloc() failed: %s.\n", + __XINE_FUNCTION__, strerror(errno)); + return NULL; + } + + return ptr; +} + void *xine_xmalloc_aligned(size_t alignment, size_t size, void **base) { char *ptr; @@ -265,6 +286,19 @@ void *xine_xmalloc_aligned(size_t alignment, size_t size, void **base) { return ptr; } +void *xine_memdup (const void *src, size_t length) +{ + void *dst = malloc (length); + return xine_fast_memcpy (dst, src, length); +} + +void *xine_memdup0 (const void *src, size_t length) +{ + char *dst = xine_xmalloc (length + 1); + dst[length] = 0; + return xine_fast_memcpy (dst, src, length); +} + #ifdef WIN32 /* * Parse command line with Windows XP syntax and copy the command (argv[0]). @@ -456,38 +490,40 @@ void xine_usec_sleep(unsigned usec) { /* print a hexdump of length bytes from the data given in buf */ -void xine_hexdump (const char *buf, int length) { - int i,j; - unsigned char c; +void xine_hexdump (const void *buf_gen, int length) { + static const char separator[70] = "---------------------------------------------------------------------"; + + const uint8_t *const buf = (const uint8_t*)buf; + int j = 0; /* printf ("Hexdump: %i Bytes\n", length);*/ - for(j=0; j<69; j++) - printf ("-"); - printf ("\n"); + puts(separator); - j=0; while(j<length) { + int i; + const int imax = (j+16 < length) ? (j+16) : length; + printf ("%04X ",j); for (i=j; i<j+16; i++) { if( i<length ) - printf ("%02X ", (unsigned char) buf[i]); + printf ("%02X ", buf[i]); else printf(" "); } - for (i=j;i<(j+16<length?j+16:length);i++) { - c=buf[i]; + + for (i=j; i < imax; i++) { + uint8_t c = buf[i]; if ((c>=32) && (c<127)) - printf ("%c", c); - else - printf ("."); + c = '.'; + + fputc(c, stdout); } j=i; - printf("\n"); + + fputc('\n', stdout); } - for(j=0; j<69; j++) - printf("-"); - printf("\n"); + puts(separator); } @@ -504,7 +540,7 @@ static const lang_locale_t *_get_first_lang_locale(const char *lcal) { else lang_len = strlen(lcal); - while(llocale->language) { + while(*(llocale->language)) { if(!strncmp(lcal, llocale->language, lang_len)) { if ((!mod && !llocale->modifier) || (mod && llocale->modifier && !strcmp(mod, llocale->modifier))) return llocale; diff --git a/src/xine-utils/xine_buffer.c b/src/xine-utils/xine_buffer.c index 190ab5197..3891aec11 100644 --- a/src/xine-utils/xine_buffer.c +++ b/src/xine-utils/xine_buffer.c @@ -58,7 +58,7 @@ #define LOG */ -#include "xineutils.h" +#include <xine/xineutils.h> #define CHECKS diff --git a/src/xine-utils/xine_buffer.h b/src/xine-utils/xine_buffer.h deleted file mode 100644 index 84511bd1b..000000000 --- a/src/xine-utils/xine_buffer.h +++ /dev/null @@ -1,136 +0,0 @@ -/* - * Copyright (C) 2000-2004 the xine project - * - * This file is part of xine, a free video player. - * - * xine 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. - * - * xine is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA - * - * - * generic dynamic buffer functions. The goals - * of these functions are (in fact many of these points - * are todos): - * - dynamic allocation and reallocation depending - * on the size of data written to it. - * - fast and transparent access to the data. - * The user sees only the raw data chunk as it is - * returned by the well-known malloc function. - * This is necessary since not all data-accessing - * functions can be wrapped here. - * - some additional health checks are made during - * development (eg boundary checks after direct - * access to a buffer). This can be turned off in - * production state for higher performance. - * - A lot of convenient string and memory manipulation - * functions are implemented here, where the user - * do not have to care about memory chunk sizes. - * - Some garbage collention could be implemented as well; - * i think of a global structure containing infos - * about all allocated chunks. This must be implemented - * in a thread-save way... - * - * Here are some drawbacks (aka policies): - * - The user must not pass indexed buffers to xine_buffer_* - * functions. - * - The pointers passed to xine_buffer_* functions may change - * (eg during reallocation). The user must respect that. - */ - -#ifndef HAVE_XINE_BUFFER_H -#define HAVE_XINE_BUFFER_H - -#ifdef XINE_COMPILE -# include <inttypes.h> -#else -# include <xine/os_types.h> -#endif - -/* - * returns an initialized pointer to a buffer. - * The buffer will be allocated in blocks of - * chunk_size bytes. This will prevent permanent - * reallocation on slow growing buffers. - */ -void *xine_buffer_init(int chunk_size) XINE_PROTECTED; - -/* - * frees a buffer, the macro ensures, that a freed - * buffer pointer is set to NULL - */ -#define xine_buffer_free(buf) buf=_xine_buffer_free(buf) -void *_xine_buffer_free(void *buf) XINE_PROTECTED; - -/* - * duplicates a buffer - */ -void *xine_buffer_dup(const void *buf) XINE_PROTECTED; - -/* - * will copy len bytes of data into buf at position index. - */ -#define xine_buffer_copyin(buf,i,data,len) \ - buf=_xine_buffer_copyin(buf,i,data,len) -void *_xine_buffer_copyin(void *buf, int index, const void *data, int len) XINE_PROTECTED; - -/* - * will copy len bytes out of buf+index into data. - * no checks are made in data. It is treated as an ordinary - * user-malloced data chunk. - */ -void xine_buffer_copyout(const void *buf, int index, void *data, int len) XINE_PROTECTED; - -/* - * set len bytes in buf+index to b. - */ -#define xine_buffer_set(buf,i,b,len) \ - buf=_xine_buffer_set(buf,i,b,len) -void *_xine_buffer_set(void *buf, int index, uint8_t b, int len) XINE_PROTECTED; - -/* - * concatenates given buf (which should contain a null terminated string) - * with another string. - */ -#define xine_buffer_strcat(buf,data) \ - buf=_xine_buffer_strcat(buf,data) -void *_xine_buffer_strcat(void *buf, const char *data) XINE_PROTECTED; - -/* - * copies given string to buf+index - */ -#define xine_buffer_strcpy(buf,index,data) \ - buf=_xine_buffer_strcpy(buf,index,data) -void *_xine_buffer_strcpy(void *buf, int index, const char *data) XINE_PROTECTED; - -/* - * returns a pointer to the first occurence of ch. - * note, that the returned pointer cannot be used - * in any other xine_buffer_* functions. - */ -char *xine_buffer_strchr(const void *buf, int ch) XINE_PROTECTED; - -/* - * get allocated memory size - */ -int xine_buffer_get_size(const void *buf) XINE_PROTECTED; - -/* - * ensures a specified buffer size if the user want to - * write directly to the buffer. Normally the special - * access functions defined here should be used. - */ -#define xine_buffer_ensure_size(buf,data) \ - buf=_xine_buffer_ensure_size(buf,data) -void *_xine_buffer_ensure_size(void *buf, int size) XINE_PROTECTED; - -#endif diff --git a/src/xine-utils/xine_check.c b/src/xine-utils/xine_check.c index f00a23832..e850f9f48 100644 --- a/src/xine-utils/xine_check.c +++ b/src/xine-utils/xine_check.c @@ -45,7 +45,7 @@ #include <unistd.h> #include "xine_check.h" -#include "xineutils.h" +#include <xine/xineutils.h> #if defined(__linux__) diff --git a/src/xine-utils/xine_check.h b/src/xine-utils/xine_check.h index 4b21bf74e..75eda102d 100644 --- a/src/xine-utils/xine_check.h +++ b/src/xine-utils/xine_check.h @@ -2,11 +2,7 @@ #define XINE_CHECK_H #include <stdio.h> -#ifdef XINE_COMPILE -# include "xine.h" -#else -# include <xine.h> -#endif +#include <xine.h> /* * Start checking xine setup here diff --git a/src/xine-utils/xine_mutex.c b/src/xine-utils/xine_mutex.c index c94f32be0..52d17d8e5 100644 --- a/src/xine-utils/xine_mutex.c +++ b/src/xine-utils/xine_mutex.c @@ -24,7 +24,7 @@ #include <stdio.h> #include <pthread.h> -#include "xineutils.h" +#include <xine/xineutils.h> /* #define DBG_MUTEX diff --git a/src/xine-utils/xineutils.h b/src/xine-utils/xineutils.h deleted file mode 100644 index 120cb3578..000000000 --- a/src/xine-utils/xineutils.h +++ /dev/null @@ -1,984 +0,0 @@ -/* - * Copyright (C) 2000-2006 the xine project - * - * This file is part of xine, a free video player. - * - * xine 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. - * - * xine is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA - */ -#ifndef XINEUTILS_H -#define XINEUTILS_H - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include <stdlib.h> -#include <string.h> -#include <stdarg.h> -#include <pthread.h> - -#ifdef XINE_COMPILE -# include <inttypes.h> -# include "attributes.h" -# include "compat.h" -# include "xmlparser.h" -# include "xine_buffer.h" -# include "configfile.h" -# include "list.h" -# include "array.h" -# include "sorted_array.h" -#else -# ifdef WIN32 -# include <winsock.h> -# else -# include <sys/time.h> -# endif -# include <xine/os_types.h> -# include <xine/attributes.h> -# include <xine/compat.h> -# include <xine/xmlparser.h> -# include <xine/xine_buffer.h> -# include <xine/configfile.h> -# include <xine/list.h> -# include <xine/array.h> -# include <xine/sorted_array.h> -#endif - -#include <stdio.h> -#include <string.h> - -/* - * Mark exported data symbols for link engine library clients with older - * Win32 compilers - */ -#if defined(WIN32) && !defined(XINE_LIBRARY_COMPILE) -# define DL_IMPORT __declspec(dllimport) -# define extern DL_IMPORT extern -#endif - - /* - * debugable mutexes - */ - - typedef struct { - pthread_mutex_t mutex; - char id[80]; - char *locked_by; - } xine_mutex_t; - - int xine_mutex_init (xine_mutex_t *mutex, const pthread_mutexattr_t *mutexattr, - const char *id) XINE_PROTECTED; - - int xine_mutex_lock (xine_mutex_t *mutex, const char *who) XINE_PROTECTED; - int xine_mutex_unlock (xine_mutex_t *mutex, const char *who) XINE_PROTECTED; - int xine_mutex_destroy (xine_mutex_t *mutex) XINE_PROTECTED; - - - - /* CPU Acceleration */ - -/* - * The type of an value that fits in an MMX register (note that long - * long constant values MUST be suffixed by LL and unsigned long long - * values by ULL, lest they be truncated by the compiler) - */ - -/* generic accelerations */ -#define MM_ACCEL_MLIB 0x00000001 - -/* x86 accelerations */ -#define MM_ACCEL_X86_MMX 0x80000000 -#define MM_ACCEL_X86_3DNOW 0x40000000 -#define MM_ACCEL_X86_MMXEXT 0x20000000 -#define MM_ACCEL_X86_SSE 0x10000000 -#define MM_ACCEL_X86_SSE2 0x08000000 - -/* powerpc accelerations and features */ -#define MM_ACCEL_PPC_ALTIVEC 0x04000000 -#define MM_ACCEL_PPC_CACHE32 0x02000000 - -/* SPARC accelerations */ - -#define MM_ACCEL_SPARC_VIS 0x01000000 -#define MM_ACCEL_SPARC_VIS2 0x00800000 - -/* x86 compat defines */ -#define MM_MMX MM_ACCEL_X86_MMX -#define MM_3DNOW MM_ACCEL_X86_3DNOW -#define MM_MMXEXT MM_ACCEL_X86_MMXEXT -#define MM_SSE MM_ACCEL_X86_SSE -#define MM_SSE2 MM_ACCEL_X86_SSE2 - -uint32_t xine_mm_accel (void) XINE_PROTECTED; - -#if defined(ARCH_X86) || defined(ARCH_X86_64) - -typedef union { - int64_t q; /* Quadword (64-bit) value */ - uint64_t uq; /* Unsigned Quadword */ - int d[2]; /* 2 Doubleword (32-bit) values */ - unsigned int ud[2]; /* 2 Unsigned Doubleword */ - short w[4]; /* 4 Word (16-bit) values */ - unsigned short uw[4]; /* 4 Unsigned Word */ - char b[8]; /* 8 Byte (8-bit) values */ - unsigned char ub[8]; /* 8 Unsigned Byte */ - float s[2]; /* Single-precision (32-bit) value */ -} ATTR_ALIGN(8) mmx_t; /* On an 8-byte (64-bit) boundary */ - - - -#define mmx_i2r(op,imm,reg) \ - __asm__ __volatile__ (#op " %0, %%" #reg \ - : /* nothing */ \ - : "i" (imm) ) - -#define mmx_m2r(op,mem,reg) \ - __asm__ __volatile__ (#op " %0, %%" #reg \ - : /* nothing */ \ - : "m" (mem)) - -#define mmx_r2m(op,reg,mem) \ - __asm__ __volatile__ (#op " %%" #reg ", %0" \ - : "=m" (mem) \ - : /* nothing */ ) - -#define mmx_r2r(op,regs,regd) \ - __asm__ __volatile__ (#op " %" #regs ", %" #regd) - - -#define emms() __asm__ __volatile__ ("emms") - -#define movd_m2r(var,reg) mmx_m2r (movd, var, reg) -#define movd_r2m(reg,var) mmx_r2m (movd, reg, var) -#define movd_r2r(regs,regd) mmx_r2r (movd, regs, regd) - -#define movq_m2r(var,reg) mmx_m2r (movq, var, reg) -#define movq_r2m(reg,var) mmx_r2m (movq, reg, var) -#define movq_r2r(regs,regd) mmx_r2r (movq, regs, regd) - -#define packssdw_m2r(var,reg) mmx_m2r (packssdw, var, reg) -#define packssdw_r2r(regs,regd) mmx_r2r (packssdw, regs, regd) -#define packsswb_m2r(var,reg) mmx_m2r (packsswb, var, reg) -#define packsswb_r2r(regs,regd) mmx_r2r (packsswb, regs, regd) - -#define packuswb_m2r(var,reg) mmx_m2r (packuswb, var, reg) -#define packuswb_r2r(regs,regd) mmx_r2r (packuswb, regs, regd) - -#define paddb_m2r(var,reg) mmx_m2r (paddb, var, reg) -#define paddb_r2r(regs,regd) mmx_r2r (paddb, regs, regd) -#define paddd_m2r(var,reg) mmx_m2r (paddd, var, reg) -#define paddd_r2r(regs,regd) mmx_r2r (paddd, regs, regd) -#define paddw_m2r(var,reg) mmx_m2r (paddw, var, reg) -#define paddw_r2r(regs,regd) mmx_r2r (paddw, regs, regd) - -#define paddsb_m2r(var,reg) mmx_m2r (paddsb, var, reg) -#define paddsb_r2r(regs,regd) mmx_r2r (paddsb, regs, regd) -#define paddsw_m2r(var,reg) mmx_m2r (paddsw, var, reg) -#define paddsw_r2r(regs,regd) mmx_r2r (paddsw, regs, regd) - -#define paddusb_m2r(var,reg) mmx_m2r (paddusb, var, reg) -#define paddusb_r2r(regs,regd) mmx_r2r (paddusb, regs, regd) -#define paddusw_m2r(var,reg) mmx_m2r (paddusw, var, reg) -#define paddusw_r2r(regs,regd) mmx_r2r (paddusw, regs, regd) - -#define pand_m2r(var,reg) mmx_m2r (pand, var, reg) -#define pand_r2r(regs,regd) mmx_r2r (pand, regs, regd) - -#define pandn_m2r(var,reg) mmx_m2r (pandn, var, reg) -#define pandn_r2r(regs,regd) mmx_r2r (pandn, regs, regd) - -#define pcmpeqb_m2r(var,reg) mmx_m2r (pcmpeqb, var, reg) -#define pcmpeqb_r2r(regs,regd) mmx_r2r (pcmpeqb, regs, regd) -#define pcmpeqd_m2r(var,reg) mmx_m2r (pcmpeqd, var, reg) -#define pcmpeqd_r2r(regs,regd) mmx_r2r (pcmpeqd, regs, regd) -#define pcmpeqw_m2r(var,reg) mmx_m2r (pcmpeqw, var, reg) -#define pcmpeqw_r2r(regs,regd) mmx_r2r (pcmpeqw, regs, regd) - -#define pcmpgtb_m2r(var,reg) mmx_m2r (pcmpgtb, var, reg) -#define pcmpgtb_r2r(regs,regd) mmx_r2r (pcmpgtb, regs, regd) -#define pcmpgtd_m2r(var,reg) mmx_m2r (pcmpgtd, var, reg) -#define pcmpgtd_r2r(regs,regd) mmx_r2r (pcmpgtd, regs, regd) -#define pcmpgtw_m2r(var,reg) mmx_m2r (pcmpgtw, var, reg) -#define pcmpgtw_r2r(regs,regd) mmx_r2r (pcmpgtw, regs, regd) - -#define pmaddwd_m2r(var,reg) mmx_m2r (pmaddwd, var, reg) -#define pmaddwd_r2r(regs,regd) mmx_r2r (pmaddwd, regs, regd) - -#define pmulhw_m2r(var,reg) mmx_m2r (pmulhw, var, reg) -#define pmulhw_r2r(regs,regd) mmx_r2r (pmulhw, regs, regd) - -#define pmullw_m2r(var,reg) mmx_m2r (pmullw, var, reg) -#define pmullw_r2r(regs,regd) mmx_r2r (pmullw, regs, regd) - -#define por_m2r(var,reg) mmx_m2r (por, var, reg) -#define por_r2r(regs,regd) mmx_r2r (por, regs, regd) - -#define pslld_i2r(imm,reg) mmx_i2r (pslld, imm, reg) -#define pslld_m2r(var,reg) mmx_m2r (pslld, var, reg) -#define pslld_r2r(regs,regd) mmx_r2r (pslld, regs, regd) -#define psllq_i2r(imm,reg) mmx_i2r (psllq, imm, reg) -#define psllq_m2r(var,reg) mmx_m2r (psllq, var, reg) -#define psllq_r2r(regs,regd) mmx_r2r (psllq, regs, regd) -#define psllw_i2r(imm,reg) mmx_i2r (psllw, imm, reg) -#define psllw_m2r(var,reg) mmx_m2r (psllw, var, reg) -#define psllw_r2r(regs,regd) mmx_r2r (psllw, regs, regd) - -#define psrad_i2r(imm,reg) mmx_i2r (psrad, imm, reg) -#define psrad_m2r(var,reg) mmx_m2r (psrad, var, reg) -#define psrad_r2r(regs,regd) mmx_r2r (psrad, regs, regd) -#define psraw_i2r(imm,reg) mmx_i2r (psraw, imm, reg) -#define psraw_m2r(var,reg) mmx_m2r (psraw, var, reg) -#define psraw_r2r(regs,regd) mmx_r2r (psraw, regs, regd) - -#define psrld_i2r(imm,reg) mmx_i2r (psrld, imm, reg) -#define psrld_m2r(var,reg) mmx_m2r (psrld, var, reg) -#define psrld_r2r(regs,regd) mmx_r2r (psrld, regs, regd) -#define psrlq_i2r(imm,reg) mmx_i2r (psrlq, imm, reg) -#define psrlq_m2r(var,reg) mmx_m2r (psrlq, var, reg) -#define psrlq_r2r(regs,regd) mmx_r2r (psrlq, regs, regd) -#define psrlw_i2r(imm,reg) mmx_i2r (psrlw, imm, reg) -#define psrlw_m2r(var,reg) mmx_m2r (psrlw, var, reg) -#define psrlw_r2r(regs,regd) mmx_r2r (psrlw, regs, regd) - -#define psubb_m2r(var,reg) mmx_m2r (psubb, var, reg) -#define psubb_r2r(regs,regd) mmx_r2r (psubb, regs, regd) -#define psubd_m2r(var,reg) mmx_m2r (psubd, var, reg) -#define psubd_r2r(regs,regd) mmx_r2r (psubd, regs, regd) -#define psubw_m2r(var,reg) mmx_m2r (psubw, var, reg) -#define psubw_r2r(regs,regd) mmx_r2r (psubw, regs, regd) - -#define psubsb_m2r(var,reg) mmx_m2r (psubsb, var, reg) -#define psubsb_r2r(regs,regd) mmx_r2r (psubsb, regs, regd) -#define psubsw_m2r(var,reg) mmx_m2r (psubsw, var, reg) -#define psubsw_r2r(regs,regd) mmx_r2r (psubsw, regs, regd) - -#define psubusb_m2r(var,reg) mmx_m2r (psubusb, var, reg) -#define psubusb_r2r(regs,regd) mmx_r2r (psubusb, regs, regd) -#define psubusw_m2r(var,reg) mmx_m2r (psubusw, var, reg) -#define psubusw_r2r(regs,regd) mmx_r2r (psubusw, regs, regd) - -#define punpckhbw_m2r(var,reg) mmx_m2r (punpckhbw, var, reg) -#define punpckhbw_r2r(regs,regd) mmx_r2r (punpckhbw, regs, regd) -#define punpckhdq_m2r(var,reg) mmx_m2r (punpckhdq, var, reg) -#define punpckhdq_r2r(regs,regd) mmx_r2r (punpckhdq, regs, regd) -#define punpckhwd_m2r(var,reg) mmx_m2r (punpckhwd, var, reg) -#define punpckhwd_r2r(regs,regd) mmx_r2r (punpckhwd, regs, regd) - -#define punpcklbw_m2r(var,reg) mmx_m2r (punpcklbw, var, reg) -#define punpcklbw_r2r(regs,regd) mmx_r2r (punpcklbw, regs, regd) -#define punpckldq_m2r(var,reg) mmx_m2r (punpckldq, var, reg) -#define punpckldq_r2r(regs,regd) mmx_r2r (punpckldq, regs, regd) -#define punpcklwd_m2r(var,reg) mmx_m2r (punpcklwd, var, reg) -#define punpcklwd_r2r(regs,regd) mmx_r2r (punpcklwd, regs, regd) - -#define pxor_m2r(var,reg) mmx_m2r (pxor, var, reg) -#define pxor_r2r(regs,regd) mmx_r2r (pxor, regs, regd) - - -/* 3DNOW extensions */ - -#define pavgusb_m2r(var,reg) mmx_m2r (pavgusb, var, reg) -#define pavgusb_r2r(regs,regd) mmx_r2r (pavgusb, regs, regd) - - -/* AMD MMX extensions - also available in intel SSE */ - - -#define mmx_m2ri(op,mem,reg,imm) \ - __asm__ __volatile__ (#op " %1, %0, %%" #reg \ - : /* nothing */ \ - : "X" (mem), "X" (imm)) -#define mmx_r2ri(op,regs,regd,imm) \ - __asm__ __volatile__ (#op " %0, %%" #regs ", %%" #regd \ - : /* nothing */ \ - : "X" (imm) ) - -#define mmx_fetch(mem,hint) \ - __asm__ __volatile__ ("prefetch" #hint " %0" \ - : /* nothing */ \ - : "X" (mem)) - - -#define maskmovq(regs,maskreg) mmx_r2ri (maskmovq, regs, maskreg) - -#define movntq_r2m(mmreg,var) mmx_r2m (movntq, mmreg, var) - -#define pavgb_m2r(var,reg) mmx_m2r (pavgb, var, reg) -#define pavgb_r2r(regs,regd) mmx_r2r (pavgb, regs, regd) -#define pavgw_m2r(var,reg) mmx_m2r (pavgw, var, reg) -#define pavgw_r2r(regs,regd) mmx_r2r (pavgw, regs, regd) - -#define pextrw_r2r(mmreg,reg,imm) mmx_r2ri (pextrw, mmreg, reg, imm) - -#define pinsrw_r2r(reg,mmreg,imm) mmx_r2ri (pinsrw, reg, mmreg, imm) - -#define pmaxsw_m2r(var,reg) mmx_m2r (pmaxsw, var, reg) -#define pmaxsw_r2r(regs,regd) mmx_r2r (pmaxsw, regs, regd) - -#define pmaxub_m2r(var,reg) mmx_m2r (pmaxub, var, reg) -#define pmaxub_r2r(regs,regd) mmx_r2r (pmaxub, regs, regd) - -#define pminsw_m2r(var,reg) mmx_m2r (pminsw, var, reg) -#define pminsw_r2r(regs,regd) mmx_r2r (pminsw, regs, regd) - -#define pminub_m2r(var,reg) mmx_m2r (pminub, var, reg) -#define pminub_r2r(regs,regd) mmx_r2r (pminub, regs, regd) - -#define pmovmskb(mmreg,reg) \ - __asm__ __volatile__ ("movmskps %" #mmreg ", %" #reg) - -#define pmulhuw_m2r(var,reg) mmx_m2r (pmulhuw, var, reg) -#define pmulhuw_r2r(regs,regd) mmx_r2r (pmulhuw, regs, regd) - -#define prefetcht0(mem) mmx_fetch (mem, t0) -#define prefetcht1(mem) mmx_fetch (mem, t1) -#define prefetcht2(mem) mmx_fetch (mem, t2) -#define prefetchnta(mem) mmx_fetch (mem, nta) - -#define psadbw_m2r(var,reg) mmx_m2r (psadbw, var, reg) -#define psadbw_r2r(regs,regd) mmx_r2r (psadbw, regs, regd) - -#define pshufw_m2r(var,reg,imm) mmx_m2ri(pshufw, var, reg, imm) -#define pshufw_r2r(regs,regd,imm) mmx_r2ri(pshufw, regs, regd, imm) - -#define sfence() __asm__ __volatile__ ("sfence\n\t") - -typedef union { - float sf[4]; /* Single-precision (32-bit) value */ -} ATTR_ALIGN(16) sse_t; /* On a 16 byte (128-bit) boundary */ - - -#define sse_i2r(op, imm, reg) \ - __asm__ __volatile__ (#op " %0, %%" #reg \ - : /* nothing */ \ - : "X" (imm) ) - -#define sse_m2r(op, mem, reg) \ - __asm__ __volatile__ (#op " %0, %%" #reg \ - : /* nothing */ \ - : "X" (mem)) - -#define sse_r2m(op, reg, mem) \ - __asm__ __volatile__ (#op " %%" #reg ", %0" \ - : "=X" (mem) \ - : /* nothing */ ) - -#define sse_r2r(op, regs, regd) \ - __asm__ __volatile__ (#op " %" #regs ", %" #regd) - -#define sse_r2ri(op, regs, regd, imm) \ - __asm__ __volatile__ (#op " %0, %%" #regs ", %%" #regd \ - : /* nothing */ \ - : "X" (imm) ) - -#define sse_m2ri(op, mem, reg, subop) \ - __asm__ __volatile__ (#op " %0, %%" #reg ", " #subop \ - : /* nothing */ \ - : "X" (mem)) - - -#define movaps_m2r(var, reg) sse_m2r(movaps, var, reg) -#define movaps_r2m(reg, var) sse_r2m(movaps, reg, var) -#define movaps_r2r(regs, regd) sse_r2r(movaps, regs, regd) - -#define movntps_r2m(xmmreg, var) sse_r2m(movntps, xmmreg, var) - -#define movups_m2r(var, reg) sse_m2r(movups, var, reg) -#define movups_r2m(reg, var) sse_r2m(movups, reg, var) -#define movups_r2r(regs, regd) sse_r2r(movups, regs, regd) - -#define movhlps_r2r(regs, regd) sse_r2r(movhlps, regs, regd) - -#define movlhps_r2r(regs, regd) sse_r2r(movlhps, regs, regd) - -#define movhps_m2r(var, reg) sse_m2r(movhps, var, reg) -#define movhps_r2m(reg, var) sse_r2m(movhps, reg, var) - -#define movlps_m2r(var, reg) sse_m2r(movlps, var, reg) -#define movlps_r2m(reg, var) sse_r2m(movlps, reg, var) - -#define movss_m2r(var, reg) sse_m2r(movss, var, reg) -#define movss_r2m(reg, var) sse_r2m(movss, reg, var) -#define movss_r2r(regs, regd) sse_r2r(movss, regs, regd) - -#define shufps_m2r(var, reg, index) sse_m2ri(shufps, var, reg, index) -#define shufps_r2r(regs, regd, index) sse_r2ri(shufps, regs, regd, index) - -#define cvtpi2ps_m2r(var, xmmreg) sse_m2r(cvtpi2ps, var, xmmreg) -#define cvtpi2ps_r2r(mmreg, xmmreg) sse_r2r(cvtpi2ps, mmreg, xmmreg) - -#define cvtps2pi_m2r(var, mmreg) sse_m2r(cvtps2pi, var, mmreg) -#define cvtps2pi_r2r(xmmreg, mmreg) sse_r2r(cvtps2pi, mmreg, xmmreg) - -#define cvttps2pi_m2r(var, mmreg) sse_m2r(cvttps2pi, var, mmreg) -#define cvttps2pi_r2r(xmmreg, mmreg) sse_r2r(cvttps2pi, mmreg, xmmreg) - -#define cvtsi2ss_m2r(var, xmmreg) sse_m2r(cvtsi2ss, var, xmmreg) -#define cvtsi2ss_r2r(reg, xmmreg) sse_r2r(cvtsi2ss, reg, xmmreg) - -#define cvtss2si_m2r(var, reg) sse_m2r(cvtss2si, var, reg) -#define cvtss2si_r2r(xmmreg, reg) sse_r2r(cvtss2si, xmmreg, reg) - -#define cvttss2si_m2r(var, reg) sse_m2r(cvtss2si, var, reg) -#define cvttss2si_r2r(xmmreg, reg) sse_r2r(cvtss2si, xmmreg, reg) - -#define movmskps(xmmreg, reg) \ - __asm__ __volatile__ ("movmskps %" #xmmreg ", %" #reg) - -#define addps_m2r(var, reg) sse_m2r(addps, var, reg) -#define addps_r2r(regs, regd) sse_r2r(addps, regs, regd) - -#define addss_m2r(var, reg) sse_m2r(addss, var, reg) -#define addss_r2r(regs, regd) sse_r2r(addss, regs, regd) - -#define subps_m2r(var, reg) sse_m2r(subps, var, reg) -#define subps_r2r(regs, regd) sse_r2r(subps, regs, regd) - -#define subss_m2r(var, reg) sse_m2r(subss, var, reg) -#define subss_r2r(regs, regd) sse_r2r(subss, regs, regd) - -#define mulps_m2r(var, reg) sse_m2r(mulps, var, reg) -#define mulps_r2r(regs, regd) sse_r2r(mulps, regs, regd) - -#define mulss_m2r(var, reg) sse_m2r(mulss, var, reg) -#define mulss_r2r(regs, regd) sse_r2r(mulss, regs, regd) - -#define divps_m2r(var, reg) sse_m2r(divps, var, reg) -#define divps_r2r(regs, regd) sse_r2r(divps, regs, regd) - -#define divss_m2r(var, reg) sse_m2r(divss, var, reg) -#define divss_r2r(regs, regd) sse_r2r(divss, regs, regd) - -#define rcpps_m2r(var, reg) sse_m2r(rcpps, var, reg) -#define rcpps_r2r(regs, regd) sse_r2r(rcpps, regs, regd) - -#define rcpss_m2r(var, reg) sse_m2r(rcpss, var, reg) -#define rcpss_r2r(regs, regd) sse_r2r(rcpss, regs, regd) - -#define rsqrtps_m2r(var, reg) sse_m2r(rsqrtps, var, reg) -#define rsqrtps_r2r(regs, regd) sse_r2r(rsqrtps, regs, regd) - -#define rsqrtss_m2r(var, reg) sse_m2r(rsqrtss, var, reg) -#define rsqrtss_r2r(regs, regd) sse_r2r(rsqrtss, regs, regd) - -#define sqrtps_m2r(var, reg) sse_m2r(sqrtps, var, reg) -#define sqrtps_r2r(regs, regd) sse_r2r(sqrtps, regs, regd) - -#define sqrtss_m2r(var, reg) sse_m2r(sqrtss, var, reg) -#define sqrtss_r2r(regs, regd) sse_r2r(sqrtss, regs, regd) - -#define andps_m2r(var, reg) sse_m2r(andps, var, reg) -#define andps_r2r(regs, regd) sse_r2r(andps, regs, regd) - -#define andnps_m2r(var, reg) sse_m2r(andnps, var, reg) -#define andnps_r2r(regs, regd) sse_r2r(andnps, regs, regd) - -#define orps_m2r(var, reg) sse_m2r(orps, var, reg) -#define orps_r2r(regs, regd) sse_r2r(orps, regs, regd) - -#define xorps_m2r(var, reg) sse_m2r(xorps, var, reg) -#define xorps_r2r(regs, regd) sse_r2r(xorps, regs, regd) - -#define maxps_m2r(var, reg) sse_m2r(maxps, var, reg) -#define maxps_r2r(regs, regd) sse_r2r(maxps, regs, regd) - -#define maxss_m2r(var, reg) sse_m2r(maxss, var, reg) -#define maxss_r2r(regs, regd) sse_r2r(maxss, regs, regd) - -#define minps_m2r(var, reg) sse_m2r(minps, var, reg) -#define minps_r2r(regs, regd) sse_r2r(minps, regs, regd) - -#define minss_m2r(var, reg) sse_m2r(minss, var, reg) -#define minss_r2r(regs, regd) sse_r2r(minss, regs, regd) - -#define cmpps_m2r(var, reg, op) sse_m2ri(cmpps, var, reg, op) -#define cmpps_r2r(regs, regd, op) sse_r2ri(cmpps, regs, regd, op) - -#define cmpeqps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 0) -#define cmpeqps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 0) - -#define cmpltps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 1) -#define cmpltps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 1) - -#define cmpleps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 2) -#define cmpleps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 2) - -#define cmpunordps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 3) -#define cmpunordps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 3) - -#define cmpneqps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 4) -#define cmpneqps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 4) - -#define cmpnltps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 5) -#define cmpnltps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 5) - -#define cmpnleps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 6) -#define cmpnleps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 6) - -#define cmpordps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 7) -#define cmpordps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 7) - -#define cmpss_m2r(var, reg, op) sse_m2ri(cmpss, var, reg, op) -#define cmpss_r2r(regs, regd, op) sse_r2ri(cmpss, regs, regd, op) - -#define cmpeqss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 0) -#define cmpeqss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 0) - -#define cmpltss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 1) -#define cmpltss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 1) - -#define cmpless_m2r(var, reg) sse_m2ri(cmpss, var, reg, 2) -#define cmpless_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 2) - -#define cmpunordss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 3) -#define cmpunordss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 3) - -#define cmpneqss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 4) -#define cmpneqss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 4) - -#define cmpnltss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 5) -#define cmpnltss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 5) - -#define cmpnless_m2r(var, reg) sse_m2ri(cmpss, var, reg, 6) -#define cmpnless_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 6) - -#define cmpordss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 7) -#define cmpordss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 7) - -#define comiss_m2r(var, reg) sse_m2r(comiss, var, reg) -#define comiss_r2r(regs, regd) sse_r2r(comiss, regs, regd) - -#define ucomiss_m2r(var, reg) sse_m2r(ucomiss, var, reg) -#define ucomiss_r2r(regs, regd) sse_r2r(ucomiss, regs, regd) - -#define unpcklps_m2r(var, reg) sse_m2r(unpcklps, var, reg) -#define unpcklps_r2r(regs, regd) sse_r2r(unpcklps, regs, regd) - -#define unpckhps_m2r(var, reg) sse_m2r(unpckhps, var, reg) -#define unpckhps_r2r(regs, regd) sse_r2r(unpckhps, regs, regd) - -#define fxrstor(mem) \ - __asm__ __volatile__ ("fxrstor %0" \ - : /* nothing */ \ - : "X" (mem)) - -#define fxsave(mem) \ - __asm__ __volatile__ ("fxsave %0" \ - : /* nothing */ \ - : "X" (mem)) - -#define stmxcsr(mem) \ - __asm__ __volatile__ ("stmxcsr %0" \ - : /* nothing */ \ - : "X" (mem)) - -#define ldmxcsr(mem) \ - __asm__ __volatile__ ("ldmxcsr %0" \ - : /* nothing */ \ - : "X" (mem)) -#endif /*ARCH_X86 */ - - - /* Optimized/fast memcpy */ - -extern void *(* xine_fast_memcpy)(void *to, const void *from, size_t len) XINE_PROTECTED; - -#ifdef HAVE_XINE_INTERNAL_H -/* Benchmark available memcpy methods */ -void xine_probe_fast_memcpy(xine_t *xine) XINE_PROTECTED; -#endif - - -/* - * Debug stuff - */ -/* - * profiling (unworkable in non DEBUG isn't defined) - */ -void xine_profiler_init (void) XINE_PROTECTED; -int xine_profiler_allocate_slot (const char *label) XINE_PROTECTED; -void xine_profiler_start_count (int id) XINE_PROTECTED; -void xine_profiler_stop_count (int id) XINE_PROTECTED; -void xine_profiler_print_results (void) XINE_PROTECTED; - -/* - * Allocate and clean memory size_t 'size', then return the pointer - * to the allocated memory. - */ -#if !defined(__GNUC__) || __GNUC__ < 3 -void *xine_xmalloc(size_t size) XINE_PROTECTED; -#else -void *xine_xmalloc(size_t size) __attribute__ ((__malloc__)) XINE_PROTECTED; -#endif - -/* - * Same as above, but memory is aligned to 'alignement'. - * **base is used to return pointer to un-aligned memory, use - * this to free the mem chunk - */ -void *xine_xmalloc_aligned(size_t alignment, size_t size, void **base) XINE_PROTECTED; - -/* - * Get user home directory. - */ -const char *xine_get_homedir(void) XINE_PROTECTED; - -#if defined(WIN32) || defined(__CYGWIN__) -/* - * Get other xine directories. - */ -const char *xine_get_plugindir(void) XINE_PROTECTED; -const char *xine_get_fontdir(void) XINE_PROTECTED; -const char *xine_get_localedir(void) XINE_PROTECTED; -#endif - -/* - * Clean a string (remove spaces and '=' at the begin, - * and '\n', '\r' and spaces at the end. - */ -char *xine_chomp (char *str) XINE_PROTECTED; - -/* - * A thread-safe usecond sleep - */ -void xine_usec_sleep(unsigned usec) XINE_PROTECTED; - - - /* - * Some string functions - */ - - -void xine_strdupa(char *dest, char *src) XINE_PROTECTED; -#define xine_strdupa(d, s) do { \ - (d) = NULL; \ - if((s) != NULL) { \ - (d) = (char *) alloca(strlen((s)) + 1); \ - strcpy((d), (s)); \ - } \ - } while(0) - -/* compatibility macros */ -#define xine_strpbrk(S, ACCEPT) strpbrk((S), (ACCEPT)) -#define xine_strsep(STRINGP, DELIM) strsep((STRINGP), (DELIM)) -#define xine_setenv(NAME, VAL, XX) setenv((NAME), (VAL), (XX)) - -/* - * Color Conversion Utility Functions - * The following data structures and functions facilitate the conversion - * of RGB images to packed YUV (YUY2) images. There are also functions to - * convert from YUV9 -> YV12. All of the meaty details are written in - * color.c. - */ - -typedef struct yuv_planes_s { - - unsigned char *y; - unsigned char *u; - unsigned char *v; - unsigned int row_width; /* frame width */ - unsigned int row_count; /* frame height */ - -} yuv_planes_t; - -void init_yuv_conversion(void) XINE_PROTECTED; -void init_yuv_planes(yuv_planes_t *yuv_planes, int width, int height) XINE_PROTECTED; -void free_yuv_planes(yuv_planes_t *yuv_planes) XINE_PROTECTED; - -extern void (*yuv444_to_yuy2) - (const yuv_planes_t *yuv_planes, unsigned char *yuy2_map, int pitch) XINE_PROTECTED; -extern void (*yuv9_to_yv12) - (const unsigned char *y_src, int y_src_pitch, unsigned char *y_dest, int y_dest_pitch, - const unsigned char *u_src, int u_src_pitch, unsigned char *u_dest, int u_dest_pitch, - const unsigned char *v_src, int v_src_pitch, unsigned char *v_dest, int v_dest_pitch, - int width, int height) XINE_PROTECTED; -extern void (*yuv411_to_yv12) - (const unsigned char *y_src, int y_src_pitch, unsigned char *y_dest, int y_dest_pitch, - const unsigned char *u_src, int u_src_pitch, unsigned char *u_dest, int u_dest_pitch, - const unsigned char *v_src, int v_src_pitch, unsigned char *v_dest, int v_dest_pitch, - int width, int height) XINE_PROTECTED; -extern void (*yv12_to_yuy2) - (const unsigned char *y_src, int y_src_pitch, - const unsigned char *u_src, int u_src_pitch, - const unsigned char *v_src, int v_src_pitch, - unsigned char *yuy2_map, int yuy2_pitch, - int width, int height, int progressive) XINE_PROTECTED; -extern void (*yuy2_to_yv12) - (const unsigned char *yuy2_map, int yuy2_pitch, - unsigned char *y_dst, int y_dst_pitch, - unsigned char *u_dst, int u_dst_pitch, - unsigned char *v_dst, int v_dst_pitch, - int width, int height) XINE_PROTECTED; - -#define SCALEFACTOR 65536 -#define CENTERSAMPLE 128 - -#define COMPUTE_Y(r, g, b) \ - (unsigned char) \ - ((y_r_table[r] + y_g_table[g] + y_b_table[b]) / SCALEFACTOR) -#define COMPUTE_U(r, g, b) \ - (unsigned char) \ - ((u_r_table[r] + u_g_table[g] + u_b_table[b]) / SCALEFACTOR + CENTERSAMPLE) -#define COMPUTE_V(r, g, b) \ - (unsigned char) \ - ((v_r_table[r] + v_g_table[g] + v_b_table[b]) / SCALEFACTOR + CENTERSAMPLE) - -#define UNPACK_BGR15(packed_pixel, r, g, b) \ - b = (packed_pixel & 0x7C00) >> 7; \ - g = (packed_pixel & 0x03E0) >> 2; \ - r = (packed_pixel & 0x001F) << 3; - -#define UNPACK_BGR16(packed_pixel, r, g, b) \ - b = (packed_pixel & 0xF800) >> 8; \ - g = (packed_pixel & 0x07E0) >> 3; \ - r = (packed_pixel & 0x001F) << 3; - -#define UNPACK_RGB15(packed_pixel, r, g, b) \ - r = (packed_pixel & 0x7C00) >> 7; \ - g = (packed_pixel & 0x03E0) >> 2; \ - b = (packed_pixel & 0x001F) << 3; - -#define UNPACK_RGB16(packed_pixel, r, g, b) \ - r = (packed_pixel & 0xF800) >> 8; \ - g = (packed_pixel & 0x07E0) >> 3; \ - b = (packed_pixel & 0x001F) << 3; - -extern int y_r_table[256] XINE_PROTECTED; -extern int y_g_table[256] XINE_PROTECTED; -extern int y_b_table[256] XINE_PROTECTED; - -extern int u_r_table[256] XINE_PROTECTED; -extern int u_g_table[256] XINE_PROTECTED; -extern int u_b_table[256] XINE_PROTECTED; - -extern int v_r_table[256] XINE_PROTECTED; -extern int v_g_table[256] XINE_PROTECTED; -extern int v_b_table[256] XINE_PROTECTED; - -/* frame copying functions */ -extern void yv12_to_yv12 - (const unsigned char *y_src, int y_src_pitch, unsigned char *y_dst, int y_dst_pitch, - const unsigned char *u_src, int u_src_pitch, unsigned char *u_dst, int u_dst_pitch, - const unsigned char *v_src, int v_src_pitch, unsigned char *v_dst, int v_dst_pitch, - int width, int height) XINE_PROTECTED; -extern void yuy2_to_yuy2 - (const unsigned char *src, int src_pitch, - unsigned char *dst, int dst_pitch, - int width, int height) XINE_PROTECTED; - -/* print a hexdump of the given data */ -void xine_hexdump (const char *buf, int length) XINE_PROTECTED; - -/* - * Optimization macros for conditions - * Taken from the FIASCO L4 microkernel sources - */ -#if !defined(__GNUC__) || __GNUC__ < 3 -# define EXPECT_TRUE(x) (x) -# define EXPECT_FALSE(x) (x) -#else -# define EXPECT_TRUE(x) __builtin_expect((x),1) -# define EXPECT_FALSE(x) __builtin_expect((x),0) -#endif - -#ifdef NDEBUG -#define _x_assert(exp) \ - do { \ - if (!(exp)) \ - fprintf(stderr, "assert: %s:%d: %s: Assertion `%s' failed.\n", \ - __FILE__, __LINE__, __XINE_FUNCTION__, #exp); \ - } while(0) -#else -#define _x_assert(exp) \ - do { \ - if (!(exp)) { \ - fprintf(stderr, "assert: %s:%d: %s: Assertion `%s' failed.\n", \ - __FILE__, __LINE__, __XINE_FUNCTION__, #exp); \ - abort(); \ - } \ - } while(0) -#endif - -#define _x_abort() \ - do { \ - fprintf(stderr, "abort: %s:%d: %s: Aborting.\n", \ - __FILE__, __LINE__, __XINE_FUNCTION__); \ - abort(); \ - } while(0) - - -/****** logging with xine **********************************/ - -#ifndef LOG_MODULE - #define LOG_MODULE __FILE__ -#endif /* LOG_MODULE */ - -#define LOG_MODULE_STRING printf("%s: ", LOG_MODULE ); - -#ifdef LOG_VERBOSE - #define LONG_LOG_MODULE_STRING \ - printf("%s: (%s:%d) ", LOG_MODULE, __XINE_FUNCTION__, __LINE__ ); -#else - #define LONG_LOG_MODULE_STRING LOG_MODULE_STRING -#endif /* LOG_VERBOSE */ - -#ifdef LOG - #ifdef __GNUC__ - #define lprintf(fmt, args...) \ - do { \ - LONG_LOG_MODULE_STRING \ - printf(fmt, ##args); \ - fflush(stdout); \ - } while(0) - #else /* __GNUC__ */ - #ifdef _MSC_VER - #define lprintf(fmtargs) \ - do { \ - LONG_LOG_MODULE_STRING \ - printf("%s", fmtargs); \ - fflush(stdout); \ - } while(0) - #else /* _MSC_VER */ - #define lprintf(...) \ - do { \ - LONG_LOG_MODULE_STRING \ - printf(__VA_ARGS__); \ - fflush(stdout); \ - } while(0) - #endif /* _MSC_VER */ - #endif /* __GNUC__ */ -#else /* LOG */ - #ifdef __GNUC__ - #define lprintf(fmt, args...) do {} while(0) - #else - #ifdef _MSC_VER -void __inline lprintf(const char * fmt, ...) {} - #else - #define lprintf(...) do {} while(0) - #endif /* _MSC_VER */ - #endif /* __GNUC__ */ -#endif /* LOG */ - -#ifdef __GNUC__ - #define llprintf(cat, fmt, args...) \ - do{ \ - if(cat){ \ - LONG_LOG_MODULE_STRING \ - printf( fmt, ##args ); \ - } \ - }while(0) -#else -#ifdef _MSC_VER - #define llprintf(cat, fmtargs) \ - do{ \ - if(cat){ \ - LONG_LOG_MODULE_STRING \ - printf( "%s", fmtargs ); \ - } \ - }while(0) -#else - #define llprintf(cat, ...) \ - do{ \ - if(cat){ \ - LONG_LOG_MODULE_STRING \ - printf( __VA_ARGS__ ); \ - } \ - }while(0) -#endif /* _MSC_VER */ -#endif /* __GNUC__ */ - -#ifdef __GNUC__ - #define xprintf(xine, verbose, fmt, args...) \ - do { \ - if((xine) && (xine)->verbosity >= verbose){ \ - xine_log(xine, XINE_LOG_TRACE, fmt, ##args); \ - } \ - } while(0) -#else -#ifdef _MSC_VER -void xine_xprintf(xine_t *xine, int verbose, const char *fmt, ...); - #define xprintf xine_xprintf -#else - #define xprintf(xine, verbose, ...) \ - do { \ - if((xine) && (xine)->verbosity >= verbose){ \ - xine_log(xine, XINE_LOG_TRACE, __VA_ARGS__); \ - } \ - } while(0) -#endif /* _MSC_VER */ -#endif /* __GNUC__ */ - -/* time measuring macros for profiling tasks */ - -#ifdef DEBUG -# define XINE_PROFILE(function) \ - do { \ - struct timeval current_time; \ - double dtime; \ - gettimeofday(¤t_time, NULL); \ - dtime = -(current_time.tv_sec + (current_time.tv_usec / 1000000.0)); \ - function; \ - gettimeofday(¤t_time, NULL); \ - dtime += current_time.tv_sec + (current_time.tv_usec / 1000000.0); \ - printf("%s: (%s:%d) took %lf seconds\n", \ - LOG_MODULE, __XINE_FUNCTION__, __LINE__, dtime); \ - } while(0) -# define XINE_PROFILE_ACCUMULATE(function) \ - do { \ - struct timeval current_time; \ - static double dtime = 0; \ - gettimeofday(¤t_time, NULL); \ - dtime -= current_time.tv_sec + (current_time.tv_usec / 1000000.0); \ - function; \ - gettimeofday(¤t_time, NULL); \ - dtime += current_time.tv_sec + (current_time.tv_usec / 1000000.0); \ - printf("%s: (%s:%d) took %lf seconds\n", \ - LOG_MODULE, __XINE_FUNCTION__, __LINE__, dtime); \ - } while(0) -#else -# define XINE_PROFILE(function) function -# define XINE_PROFILE_ACCUMULATE(function) function -#endif /* DEBUG */ - -/** - * get encoding of current locale - */ -char *xine_get_system_encoding(void) XINE_PROTECTED; - -/* - * guess default encoding for the subtitles - */ -const char *xine_guess_spu_encoding(void) XINE_PROTECTED; - -/* - * use the best clock reference (API compatible with gettimeofday) - * note: it will be a monotonic clock, if available. - */ -int xine_monotonic_clock(struct timeval *tv, struct timezone *tz) XINE_PROTECTED; - -/* don't harm following code */ -#ifdef extern -# undef extern -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/src/xine-utils/xmllexer.c b/src/xine-utils/xmllexer.c index be3bdd248..75a1aafec 100644 --- a/src/xine-utils/xmllexer.c +++ b/src/xine-utils/xmllexer.c @@ -26,12 +26,12 @@ */ #ifdef XINE_COMPILE -#include "xineutils.h" +#include <xine/xineutils.h> #else #define lprintf(...) #define xine_xmalloc malloc #endif -#include "xmllexer.h" +#include <xine/xmllexer.h> #include <stdio.h> #include <ctype.h> #include <string.h> @@ -43,14 +43,11 @@ #include "bswap.h" /* private constants*/ -#define NORMAL 0 /* normal lex mode */ -#define DATA 1 /* data lex mode */ /* private global variables */ static const char * lexbuf; static int lexbuf_size = 0; static int lexbuf_pos = 0; -static int lex_mode = NORMAL; static int in_comment = 0; static char *lex_malloc = NULL; @@ -92,6 +89,12 @@ static void lex_convert (const char * buf, int size, enum utf utf) lexbuf = lex_malloc = realloc (utf8, lexbuf_size + 1); } +static enum { + NORMAL, + DATA, + CDATA, +} lex_mode = NORMAL; + void lexer_init(const char * buf, int size) { static const char boms[] = { 0xFF, 0xFE, 0, 0, 0xFE, 0xFF }, bom_utf8[] = { 0xEF, 0xBB, 0xBF }; @@ -123,86 +126,104 @@ void lexer_init(const char * buf, int size) { lprintf("buffer length %d\n", size); } +typedef enum { + STATE_UNKNOWN = -1, + STATE_IDLE, + STATE_EOL, + STATE_SEPAR, + STATE_T_M_START, + STATE_T_M_STOP_1, + STATE_T_M_STOP_2, + STATE_T_EQUAL, + STATE_T_STRING_SINGLE, + STATE_T_STRING_DOUBLE, + STATE_T_COMMENT, + STATE_T_TI_STOP, + STATE_T_DASHDASH, + STATE_T_C_STOP, + STATE_IDENT /* must be last */ +} lexer_state_t; + int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { char *tok = *_tok; int tok_size = *_tok_size; - int tok_pos = 0; - int state = 0; + lexer_state_t state = STATE_IDLE; char c; if (tok) { while ((tok_pos < tok_size) && (lexbuf_pos < lexbuf_size)) { c = lexbuf[lexbuf_pos]; - lprintf("c=%c, state=%d, in_comment=%d\n", c, state, in_comment); + lprintf("c=%c, state=%d, lex_mode=%d, in_comment=%d\n", c, state, lex_mode, in_comment); - if (lex_mode == NORMAL) { - /* normal mode */ + switch (lex_mode) { + case NORMAL: switch (state) { /* init state */ - case 0: + case STATE_IDLE: switch (c) { case '\n': case '\r': - state = 1; + state = STATE_EOL; tok[tok_pos] = c; tok_pos++; break; case ' ': case '\t': - state = 2; + state = STATE_SEPAR; tok[tok_pos] = c; tok_pos++; break; case '<': - state = 3; + state = STATE_T_M_START; tok[tok_pos] = c; tok_pos++; break; case '>': - state = 4; + state = STATE_T_M_STOP_1; tok[tok_pos] = c; tok_pos++; break; case '/': if (!in_comment) - state = 5; + state = STATE_T_M_STOP_2; tok[tok_pos] = c; tok_pos++; break; case '=': - state = 6; + state = STATE_T_EQUAL; tok[tok_pos] = c; tok_pos++; break; case '\"': /* " */ - state = 7; + state = STATE_T_STRING_DOUBLE; break; case '\'': /* " */ - state = 12; + state = STATE_T_STRING_SINGLE; break; case '-': - state = 10; + state = STATE_T_DASHDASH; tok[tok_pos] = c; tok_pos++; break; case '?': - state = 9; + if (!in_comment) + state = STATE_T_TI_STOP; tok[tok_pos] = c; tok_pos++; break; default: - state = 100; + state = STATE_IDENT; tok[tok_pos] = c; tok_pos++; break; @@ -211,7 +232,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { break; /* end of line */ - case 1: + case STATE_EOL: if (c == '\n' || (c == '\r')) { tok[tok_pos] = c; lexbuf_pos++; @@ -223,7 +244,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { break; /* T_SEPAR */ - case 2: + case STATE_SEPAR: if (c == ' ' || (c == '\t')) { tok[tok_pos] = c; lexbuf_pos++; @@ -235,7 +256,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { break; /* T_M_START < or </ or <! or <? */ - case 3: + case STATE_T_M_START: switch (c) { case '/': tok[tok_pos] = c; @@ -248,7 +269,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { tok[tok_pos] = c; lexbuf_pos++; tok_pos++; - state = 8; + state = STATE_T_COMMENT; break; case '?': tok[tok_pos] = c; @@ -264,7 +285,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { break; /* T_M_STOP_1 */ - case 4: + case STATE_T_M_STOP_1: tok[tok_pos] = '\0'; if (!in_comment) lex_mode = DATA; @@ -272,7 +293,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { break; /* T_M_STOP_2 */ - case 5: + case STATE_T_M_STOP_2: if (c == '>') { tok[tok_pos] = c; lexbuf_pos++; @@ -288,13 +309,13 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { break; /* T_EQUAL */ - case 6: + case STATE_T_EQUAL: tok[tok_pos] = '\0'; return T_EQUAL; break; /* T_STRING */ - case 7: + case STATE_T_STRING_DOUBLE: tok[tok_pos] = c; lexbuf_pos++; if (c == '\"') { /* " */ @@ -304,8 +325,8 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { tok_pos++; break; - /* T_C_START or T_DOCTYPE_START */ - case 8: + /* T_C_START or T_DOCTYPE_START or T_CDATA_START */ + case STATE_T_COMMENT: switch (c) { case '-': lexbuf_pos++; @@ -329,6 +350,17 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { return T_ERROR; } break; + case '[': + lexbuf_pos++; + if (strncmp(lexbuf + lexbuf_pos, "CDATA[", 6) == 0) { + strncpy (tok + tok_pos, "[CDATA[", 7); /* FIXME */ + lexbuf_pos += 6; + lex_mode = CDATA; + return T_CDATA_START; + } else{ + return T_ERROR; + } + break; default: /* error */ return T_ERROR; @@ -336,12 +368,14 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { break; /* T_TI_STOP */ - case 9: + case STATE_T_TI_STOP: if (c == '>') { tok[tok_pos] = c; lexbuf_pos++; tok_pos++; /* FIXME */ tok[tok_pos] = '\0'; + if (!in_comment) + lex_mode = DATA; return T_TI_STOP; } else { tok[tok_pos] = '\0'; @@ -350,24 +384,24 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { break; /* -- */ - case 10: + case STATE_T_DASHDASH: switch (c) { case '-': tok[tok_pos] = c; tok_pos++; lexbuf_pos++; - state = 11; + state = STATE_T_C_STOP; break; default: tok[tok_pos] = c; tok_pos++; lexbuf_pos++; - state = 100; + state = STATE_IDENT; } break; /* --> */ - case 11: + case STATE_T_C_STOP: switch (c) { case '>': tok[tok_pos] = c; @@ -387,12 +421,12 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { tok[tok_pos] = c; tok_pos++; lexbuf_pos++; - state = 100; + state = STATE_IDENT; } break; /* T_STRING (single quotes) */ - case 12: + case STATE_T_STRING_SINGLE: tok[tok_pos] = c; lexbuf_pos++; if (c == '\'') { /* " */ @@ -403,7 +437,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { break; /* IDENT */ - case 100: + case STATE_IDENT: switch (c) { case '<': case '>': @@ -420,13 +454,13 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { tok[tok_pos] = c; tok_pos++; lexbuf_pos++; - state = 9; + state = STATE_T_TI_STOP; break; case '-': tok[tok_pos] = c; tok_pos++; lexbuf_pos++; - state = 10; + state = STATE_T_DASHDASH; break; default: tok[tok_pos] = c; @@ -438,8 +472,9 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { lprintf("expected char \'%c\'\n", tok[tok_pos - 1]); /* FIX ME */ return T_ERROR; } - } else { - /* data mode, stop if char equal '<' */ + break; + + case DATA: /* data mode, stop if char equal '<' */ switch (c) { case '<': @@ -451,6 +486,28 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { tok_pos++; lexbuf_pos++; } + break; + + case CDATA: /* cdata mode, stop if next token is "]]>" */ + switch (c) + { + case ']': + if (strncmp(lexbuf + lexbuf_pos, "]]>", 3) == 0) { + lexbuf_pos += 3; + lex_mode = DATA; + return T_CDATA_STOP; + } else { + tok[tok_pos] = c; + tok_pos++; + lexbuf_pos++; + } + break; + default: + tok[tok_pos] = c; + tok_pos++; + lexbuf_pos++; + } + break; } } lprintf ("loop done tok_pos = %d, tok_size=%d, lexbuf_pos=%d, lexbuf_size=%d\n", @@ -474,27 +531,28 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) { /* Terminate the current token */ tok[tok_pos] = '\0'; switch (state) { - case 0: - case 1: - case 2: + case STATE_IDLE: + case STATE_EOL: + case STATE_SEPAR: return T_EOF; break; - case 3: + case STATE_T_M_START: return T_M_START_1; break; - case 4: + case STATE_T_M_STOP_1: return T_M_STOP_1; break; - case 5: + case STATE_T_M_STOP_2: return T_ERROR; break; - case 6: + case STATE_T_EQUAL: return T_EQUAL; break; - case 7: + case STATE_T_STRING_SINGLE: + case STATE_T_STRING_DOUBLE: return T_STRING; break; - case 100: + case STATE_IDENT: return T_DATA; break; default: diff --git a/src/xine-utils/xmllexer.h b/src/xine-utils/xmllexer.h deleted file mode 100644 index 425d0e70a..000000000 --- a/src/xine-utils/xmllexer.h +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright (C) 2002-2003,2007 the xine project - * - * This file is part of xine, a free video player. - * - * The xine-lib XML parser is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public License as - * published by the Free Software Foundation; either version 2 of the - * License, or (at your option) any later version. - * - * The xine-lib XML parser 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 - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with the Gnome Library; see the file COPYING.LIB. If not, - * write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth - * Floor, Boston, MA 02110, USA - */ - -/* xml lexer */ -#ifndef XML_LEXER_H -#define XML_LEXER_H - -#ifndef XINE_PROTECTED -#define XINE_PROTECTED -#endif - -/* public constants */ -#define T_ERROR -1 /* lexer error */ -#define T_EOF 0 /* end of file */ -#define T_EOL 1 /* end of line */ -#define T_SEPAR 2 /* separator ' ' '/t' '\n' '\r' */ -#define T_M_START_1 3 /* markup start < */ -#define T_M_START_2 4 /* markup start </ */ -#define T_M_STOP_1 5 /* markup stop > */ -#define T_M_STOP_2 6 /* markup stop /> */ -#define T_EQUAL 7 /* = */ -#define T_QUOTE 8 /* \" or \' */ -#define T_STRING 9 /* "string" */ -#define T_IDENT 10 /* identifier */ -#define T_DATA 11 /* data */ -#define T_C_START 12 /* <!-- */ -#define T_C_STOP 13 /* --> */ -#define T_TI_START 14 /* <? */ -#define T_TI_STOP 15 /* ?> */ -#define T_DOCTYPE_START 16 /* <!DOCTYPE */ -#define T_DOCTYPE_STOP 17 /* > */ - - -/* public functions */ -void lexer_init(const char * buf, int size) XINE_PROTECTED; -int lexer_get_token_d(char ** tok, int * tok_size, int fixed) XINE_PROTECTED; -int lexer_get_token(char * tok, int tok_size) XINE_PROTECTED; -char *lexer_decode_entities (const char *tok) XINE_PROTECTED; - -#endif diff --git a/src/xine-utils/xmlparser.c b/src/xine-utils/xmlparser.c index 14ce35c54..8ef828105 100644 --- a/src/xine-utils/xmlparser.c +++ b/src/xine-utils/xmlparser.c @@ -19,6 +19,10 @@ * Floor, Boston, MA 02110, USA */ +#ifdef XINE_COMPILE +# include "config.h" +#endif + #include <unistd.h> #include <stdio.h> #include <stdlib.h> @@ -33,13 +37,13 @@ */ #ifdef XINE_COMPILE -#include "xineutils.h" +#include <xine/xineutils.h> #else #define lprintf(...) #define xine_xmalloc malloc #endif -#include "xmllexer.h" -#include "xmlparser.h" +#include <xine/xmllexer.h> +#include <xine/xmlparser.h> #define TOKEN_SIZE 4 * 1024 @@ -73,8 +77,11 @@ static xml_node_t * new_xml_node(void) { return new_node; } +static const char cdata[] = CDATA_MARKER; + static void free_xml_node(xml_node_t * node) { - free (node->name); + if (node->name != cdata) + free (node->name); free (node->data); free(node); } @@ -149,23 +156,82 @@ void xml_parser_free_tree(xml_node_t *current_node) { xml_parser_free_tree_rec(current_node, 1); } -#define STATE_IDLE 0 -#define STATE_NODE 1 -#define STATE_COMMENT 7 +typedef enum { + /*0*/ + STATE_IDLE, + /* <foo ...> */ + STATE_NODE, + STATE_ATTRIBUTE, + STATE_NODE_CLOSE, + STATE_TAG_TERM, + STATE_ATTRIBUTE_EQUALS, + STATE_STRING, + STATE_TAG_TERM_IGNORE, + /* <?foo ...?> */ + STATE_Q_NODE, + STATE_Q_ATTRIBUTE, + STATE_Q_NODE_CLOSE, + STATE_Q_TAG_TERM, + STATE_Q_ATTRIBUTE_EQUALS, + STATE_Q_STRING, + /* Others */ + STATE_COMMENT, + STATE_DOCTYPE, + STATE_CDATA, +} parser_state_t; + +static xml_node_t *xml_parser_append_text (xml_node_t *node, xml_node_t *subnode, const char *text, int flags) +{ + if (!text || !*text) + return subnode; /* empty string -> nothing to do */ + + if ((flags & XML_PARSER_MULTI_TEXT) && subnode) { + /* we have a subtree, so we can't use node->data */ + if (subnode->name == cdata) { + /* most recent node is CDATA - append to it */ + char *newtext; + asprintf (&newtext, "%s%s", subnode->data, text); + free (subnode->data); + subnode->data = newtext; + } else { + /* most recent node is not CDATA - add a sibling */ + subnode->next = new_xml_node (); + subnode->next->name = cdata; + subnode->next->data = strdup (text); + subnode = subnode->next; + } + } else if (node->data) { + /* "no" subtree, but we have existing text - append to it */ + char *newtext; + asprintf (&newtext, "%s%s", node->data, text); + free (node->data); + node->data = newtext; + } else { + /* no text, "no" subtree - duplicate & assign */ + while (isspace (*text)) + ++text; + if (*text) + node->data = strdup (text); + } + + return subnode; +} -static int xml_parser_get_node (xml_node_t *current_node, char *root_name, int rec); +#define Q_STATE(CURRENT,NEW) (STATE_##NEW + state - STATE_##CURRENT) -static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, +static int xml_parser_get_node_internal (char ** token_buffer, int * token_buffer_size, char ** pname_buffer, int * pname_buffer_size, char ** nname_buffer, int * nname_buffer_size, - xml_node_t *current_node, char *root_name, int rec) { + xml_node_t *current_node, char *root_names[], int rec, int flags) +{ char *tok = *token_buffer; char *property_name = *pname_buffer; char *node_name = *nname_buffer; - int state = STATE_IDLE; + parser_state_t state = STATE_IDLE; int res = 0; int parse_res; int bypass_get_token = 0; + int retval = 0; /* used when state==4; non-0 if there are missing </...> */ xml_node_t *subtree = NULL; xml_node_t *current_subtree = NULL; xml_property_t *current_property = NULL; @@ -188,30 +254,33 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, /* do nothing */ break; case (T_EOF): - return 0; /* normal end */ + return retval; /* normal end */ break; case (T_M_START_1): state = STATE_NODE; break; case (T_M_START_2): - state = 3; + state = STATE_NODE_CLOSE; break; case (T_C_START): state = STATE_COMMENT; break; case (T_TI_START): - state = 8; + state = STATE_Q_NODE; break; case (T_DOCTYPE_START): - state = 9; + state = STATE_DOCTYPE; + break; + case (T_CDATA_START): + state = STATE_CDATA; break; case (T_DATA): /* current data */ - if (current_node->data) { - /* avoid a memory leak */ - free(current_node->data); + { + char *decoded = lexer_decode_entities (tok); + current_subtree = xml_parser_append_text (current_node, current_subtree, decoded, flags); + free (decoded); } - current_node->data = lexer_decode_entities(tok); lprintf("info: node data : %s\n", current_node->data); break; default: @@ -222,6 +291,7 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, break; case STATE_NODE: + case STATE_Q_NODE: switch (res) { case (T_IDENT): properties = NULL; @@ -231,14 +301,18 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, if (xml_parser_mode == XML_PARSER_CASE_INSENSITIVE) { strtoupper(tok); } - /* make sure the buffer for the node name is big enough */ - if (*token_buffer_size > *nname_buffer_size) { - *nname_buffer_size = *token_buffer_size; - *nname_buffer = realloc (*nname_buffer, *nname_buffer_size); - node_name = *nname_buffer; + if (state == STATE_Q_NODE) { + asprintf (&node_name, "?%s", tok); + free (*nname_buffer); + *nname_buffer = node_name; + *nname_buffer_size = strlen (node_name) + 1; + state = STATE_Q_ATTRIBUTE; + } else { + free (*nname_buffer); + *nname_buffer = node_name = strdup (tok); + *nname_buffer_size = strlen (node_name) + 1; + state = STATE_ATTRIBUTE; } - strcpy(node_name, tok); - state = 2; lprintf("info: current node name \"%s\"\n", node_name); break; default: @@ -247,7 +321,8 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, break; } break; - case 2: + + case STATE_ATTRIBUTE: switch (res) { case (T_EOL): case (T_SEPAR): @@ -263,8 +338,13 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, /* set node propertys */ subtree->props = properties; lprintf("info: rec %d new subtree %s\n", rec, node_name); - parse_res = xml_parser_get_node(subtree, node_name, rec + 1); - if (parse_res != 0) { + root_names[rec + 1] = strdup (node_name); + parse_res = xml_parser_get_node_internal (token_buffer, token_buffer_size, + pname_buffer, pname_buffer_size, + nname_buffer, nname_buffer_size, + subtree, root_names, rec + 1, flags); + free (root_names[rec + 1]); + if (parse_res == -1 || parse_res > 0) { return parse_res; } if (current_subtree == NULL) { @@ -274,11 +354,16 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, current_subtree->next = subtree; current_subtree = subtree; } + if (parse_res < -1) { + /* badly-formed XML (missing close tag) */ + return parse_res + 1 + (parse_res == -2); + } state = STATE_IDLE; break; case (T_M_STOP_2): /* new leaf */ /* new subtree */ + new_leaf: subtree = new_xml_node(); /* set node name */ @@ -300,6 +385,7 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, break; case (T_IDENT): /* save property name */ + new_prop: if (xml_parser_mode == XML_PARSER_CASE_INSENSITIVE) { strtoupper(tok); } @@ -310,7 +396,7 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, property_name = *pname_buffer; } strcpy(property_name, tok); - state = 5; + state = Q_STATE(ATTRIBUTE, ATTRIBUTE_EQUALS); lprintf("info: current property name \"%s\"\n", property_name); break; default: @@ -320,17 +406,50 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, } break; - case 3: + case STATE_Q_ATTRIBUTE: + switch (res) { + case (T_EOL): + case (T_SEPAR): + /* nothing */ + break; + case (T_TI_STOP): + goto new_leaf; + case (T_IDENT): + goto new_prop; + default: + lprintf("error: unexpected token \"%s\", state %d\n", tok, state); + return -1; + break; + } + break; + + case STATE_NODE_CLOSE: switch (res) { case (T_IDENT): /* must be equal to root_name */ if (xml_parser_mode == XML_PARSER_CASE_INSENSITIVE) { strtoupper(tok); } - if (strcmp(tok, root_name) == 0) { - state = 4; - } else { - lprintf("error: xml struct, tok=%s, waited_tok=%s\n", tok, root_name); + if (strcmp(tok, root_names[rec]) == 0) { + state = STATE_TAG_TERM; + } else if (flags & XML_PARSER_RELAXED) { + int r = rec; + while (--r >= 0) + if (strcmp(tok, root_names[r]) == 0) { + lprintf("warning: wanted %s, got %s - assuming missing close tags\n", root_names[rec], tok); + retval = r - rec - 1; /* -1 - (no. of implied close tags) */ + state = STATE_TAG_TERM; + break; + } + /* relaxed parsing, ignoring extra close tag (but we don't handle out-of-order) */ + if (r < 0) { + lprintf("warning: extra close tag %s - ignoring\n", tok); + state = STATE_TAG_TERM_IGNORE; + } + } + else + { + lprintf("error: xml struct, tok=%s, waited_tok=%s\n", tok, root_names[rec]); return -1; } break; @@ -342,10 +461,10 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, break; /* > expected */ - case 4: + case STATE_TAG_TERM: switch (res) { case (T_M_STOP_1): - return 0; + return retval; break; default: lprintf("error: unexpected token \"%s\", state %d\n", tok, state); @@ -355,18 +474,18 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, break; /* = or > or ident or separator expected */ - case 5: + case STATE_ATTRIBUTE_EQUALS: switch (res) { case (T_EOL): case (T_SEPAR): /* do nothing */ break; case (T_EQUAL): - state = 6; + state = STATE_STRING; break; case (T_IDENT): bypass_get_token = 1; /* jump to state 2 without get a new token */ - state = 2; + state = STATE_ATTRIBUTE; break; case (T_M_STOP_1): /* add a new property without value */ @@ -380,7 +499,42 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, current_property->name = strdup (property_name); lprintf("info: new property %s\n", current_property->name); bypass_get_token = 1; /* jump to state 2 without get a new token */ - state = 2; + state = STATE_ATTRIBUTE; + break; + default: + lprintf("error: unexpected token \"%s\", state %d\n", tok, state); + return -1; + break; + } + break; + + /* = or ?> or ident or separator expected */ + case STATE_Q_ATTRIBUTE_EQUALS: + switch (res) { + case (T_EOL): + case (T_SEPAR): + /* do nothing */ + break; + case (T_EQUAL): + state = STATE_Q_STRING; + break; + case (T_IDENT): + bypass_get_token = 1; /* jump to state 2 without get a new token */ + state = STATE_Q_ATTRIBUTE; + break; + case (T_TI_STOP): + /* add a new property without value */ + if (current_property == NULL) { + properties = new_xml_property(); + current_property = properties; + } else { + current_property->next = new_xml_property(); + current_property = current_property->next; + } + current_property->name = strdup (property_name); + lprintf("info: new property %s\n", current_property->name); + bypass_get_token = 1; /* jump to state 2 without get a new token */ + state = STATE_Q_ATTRIBUTE; break; default: lprintf("error: unexpected token \"%s\", state %d\n", tok, state); @@ -390,7 +544,8 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, break; /* string or ident or separator expected */ - case 6: + case STATE_STRING: + case STATE_Q_STRING: switch (res) { case (T_EOL): case (T_SEPAR): @@ -409,7 +564,7 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, current_property->name = strdup(property_name); current_property->value = lexer_decode_entities(tok); lprintf("info: new property %s=%s\n", current_property->name, current_property->value); - state = 2; + state = Q_STATE(STRING, ATTRIBUTE); break; default: lprintf("error: unexpected token \"%s\", state %d\n", tok, state); @@ -425,31 +580,45 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, state = STATE_IDLE; break; default: - state = STATE_COMMENT; break; } break; - /* ?> expected */ - case 8: + /* > expected */ + case STATE_DOCTYPE: switch (res) { - case (T_TI_STOP): + case (T_M_STOP_1): state = 0; break; default: - state = 8; break; } break; - /* > expected */ - case 9: + /* ]]> expected */ + case STATE_CDATA: + switch (res) { + case (T_CDATA_STOP): + current_subtree = xml_parser_append_text (current_node, current_subtree, tok, flags); + lprintf("info: node cdata : %s\n", tok); + state = STATE_IDLE; + break; + default: + lprintf("error: unexpected token \"%s\", state %d\n", tok, state); + return -1; + break; + } + break; + + /* > expected (following unmatched "</...") */ + case STATE_TAG_TERM_IGNORE: switch (res) { case (T_M_STOP_1): - state = 0; + state = STATE_IDLE; break; default: - state = 9; + lprintf("error: unexpected token \"%s\", state %d\n", tok, state); + return -1; break; } break; @@ -470,7 +639,7 @@ static int _xml_parser_get_node (char ** token_buffer, int * token_buffer_size, } } -static int xml_parser_get_node (xml_node_t *current_node, char *root_name, int rec) +static int xml_parser_get_node (xml_node_t *current_node, int flags) { int res = 0; int token_buffer_size = TOKEN_SIZE; @@ -479,11 +648,12 @@ static int xml_parser_get_node (xml_node_t *current_node, char *root_name, int r char *token_buffer = xine_xmalloc (token_buffer_size); char *pname_buffer = xine_xmalloc (pname_buffer_size); char *nname_buffer = xine_xmalloc (nname_buffer_size); - - res = _xml_parser_get_node(&token_buffer, &token_buffer_size, + char *root_names[MAX_RECURSION + 1]; + root_names[0] = ""; + res = xml_parser_get_node_internal (&token_buffer, &token_buffer_size, &pname_buffer, &pname_buffer_size, &nname_buffer, &nname_buffer_size, - current_node, root_name, rec); + current_node, root_names, 0, flags); free (token_buffer); free (pname_buffer); @@ -492,14 +662,44 @@ static int xml_parser_get_node (xml_node_t *current_node, char *root_name, int r return res; } -int xml_parser_build_tree(xml_node_t **root_node) { - xml_node_t *tmp_node; +int xml_parser_build_tree_with_options(xml_node_t **root_node, int flags) { + xml_node_t *tmp_node, *pri_node, *q_node; int res; tmp_node = new_xml_node(); - res = xml_parser_get_node(tmp_node, "", 0); - if ((tmp_node->child) && (!tmp_node->child->next)) { - *root_node = tmp_node->child; + res = xml_parser_get_node(tmp_node, flags); + + /* delete any top-level [CDATA] nodes */; + pri_node = tmp_node->child; + q_node = NULL; + while (pri_node) { + if (pri_node->name == cdata) { + xml_node_t *old = pri_node; + if (q_node) + q_node->next = pri_node->next; + else + q_node = pri_node; + pri_node = pri_node->next; + free_xml_node (old); + } else { + q_node = pri_node; + pri_node = pri_node->next; + } + } + + /* find first non-<?...?> node */; + for (pri_node = tmp_node->child, q_node = NULL; + pri_node && pri_node->name[0] == '?'; + pri_node = pri_node->next) + q_node = pri_node; /* last <?...?> node (eventually), or NULL */ + + if (pri_node && !pri_node->next) { + /* move the tail to the head (for compatibility reasons) */ + if (q_node) { + pri_node->next = tmp_node->child; + q_node->next = NULL; + } + *root_node = pri_node; free_xml_node(tmp_node); res = 0; } else { @@ -510,6 +710,10 @@ int xml_parser_build_tree(xml_node_t **root_node) { return res; } +int xml_parser_build_tree(xml_node_t **root_node) { + return xml_parser_build_tree_with_options (root_node, 0); +} + const char *xml_parser_get_property (const xml_node_t *node, const char *name) { xml_property_t *prop; @@ -628,5 +832,8 @@ static void xml_parser_dump_node (const xml_node_t *node, int indent) { } void xml_parser_dump_tree (const xml_node_t *node) { - xml_parser_dump_node (node, 0); + do { + xml_parser_dump_node (node, 0); + node = node->next; + } while (node); } diff --git a/src/xine-utils/xmlparser.h b/src/xine-utils/xmlparser.h deleted file mode 100644 index 98695a756..000000000 --- a/src/xine-utils/xmlparser.h +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Copyright (C) 2002-2003,2007 the xine project - * - * This file is part of xine, a free video player. - * - * The xine-lib XML parser is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public License as - * published by the Free Software Foundation; either version 2 of the - * License, or (at your option) any later version. - * - * The xine-lib XML parser 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 - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with the Gnome Library; see the file COPYING.LIB. If not, - * write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth - * Floor, Boston, MA 02110, USA - */ - -#ifndef XML_PARSER_H -#define XML_PARSER_H - -#ifndef XINE_PROTECTED -#define XINE_PROTECTED -#endif - -/* parser modes */ -#define XML_PARSER_CASE_INSENSITIVE 0 -#define XML_PARSER_CASE_SENSITIVE 1 - -/* return codes */ -#define XML_PARSER_OK 0 -#define XML_PARSER_ERROR 1 - - -/* xml property */ -typedef struct xml_property_s { - char *name; - char *value; - struct xml_property_s *next; -} xml_property_t; - -/* xml node */ -typedef struct xml_node_s { - char *name; - char *data; - struct xml_property_s *props; - struct xml_node_s *child; - struct xml_node_s *next; -} xml_node_t; - -void xml_parser_init(const char * buf, int size, int mode) XINE_PROTECTED; - -int xml_parser_build_tree(xml_node_t **root_node) XINE_PROTECTED; - -void xml_parser_free_tree(xml_node_t *root_node) XINE_PROTECTED; - -const char *xml_parser_get_property (const xml_node_t *node, const char *name) XINE_PROTECTED; -int xml_parser_get_property_int (const xml_node_t *node, const char *name, - int def_value) XINE_PROTECTED; -int xml_parser_get_property_bool (const xml_node_t *node, const char *name, - int def_value) XINE_PROTECTED; - -/* for output: - * returns an escaped string (free() it when done) - * input must be in ASCII or UTF-8 - */ - -typedef enum { - XML_ESCAPE_NO_QUOTE, - XML_ESCAPE_SINGLE_QUOTE, - XML_ESCAPE_DOUBLE_QUOTE -} xml_escape_quote_t; -char *xml_escape_string (const char *s, xml_escape_quote_t quote_type) XINE_PROTECTED; - -/* for debugging purposes: dump read-in xml tree in a nicely - * indented fashion - */ - -void xml_parser_dump_tree (const xml_node_t *node) XINE_PROTECTED; - -#endif |