vdr/xine-lib-vdr/src/xine-utils Makefile.am Makefile.in attributes.h color.c compat.h copy.c cpu_accel.c list.c memcpy.c monitor.c ppc_asm.tmpl ppcasm_string.S ppcasm_string.h utils.c xine_buffer.c xine_buffer.h xine_check.c xine_check.h xine_mutex.c xineutils.h xmllexer.c xmllexer.h xmlparser.c xmlparser.h
Darren Salt
pkg-vdr-dvb-changes@lists.alioth.debian.org
Mon, 04 Apr 2005 22:38:37 +0000
Update of /cvsroot/pkg-vdr-dvb/vdr/xine-lib-vdr/src/xine-utils
In directory haydn:/tmp/cvs-serv13100/src/xine-utils
Added Files:
Makefile.am Makefile.in attributes.h color.c compat.h copy.c
cpu_accel.c list.c memcpy.c monitor.c ppc_asm.tmpl
ppcasm_string.S ppcasm_string.h utils.c xine_buffer.c
xine_buffer.h xine_check.c xine_check.h xine_mutex.c
xineutils.h xmllexer.c xmllexer.h xmlparser.c xmlparser.h
Log Message:
Import of VDR-patched xine-lib.
--- NEW FILE: xine_mutex.c ---
/*
* Copyright (C) 2000-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id: xine_mutex.c,v 1.1 2005/04/04 22:38:34 dsalt-guest Exp $
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <pthread.h>
#include "xineutils.h"
#define DBG_MUTEX
int xine_mutex_init (xine_mutex_t *mutex, const pthread_mutexattr_t *mutexattr,
char *id) {
#ifdef DBG_MUTEX
strcpy (mutex->id, id);
#endif
return pthread_mutex_init (&mutex->mutex, mutexattr);
}
int xine_mutex_lock (xine_mutex_t *mutex, char *who) {
#ifndef DBG_MUTEX
return pthread_mutex_lock (&mutex->mutex);
#else
if (pthread_mutex_trylock (&mutex->mutex)) {
printf ("xine_mutex: BLOCK when %s tried to lock mutex %s because it is locked by %s. continue trying...)\n",
who, mutex->id, mutex->locked_by);
pthread_mutex_lock (&mutex->mutex);
}
printf ("xine_mutex: %s has now locked mutex %s\n",
who, mutex->id);
mutex->locked_by = who;
return 1;
#endif
}
int xine_mutex_unlock (xine_mutex_t *mutex, char *who) {
printf ("xine_mutex: mutex %s unlocked by %s\n",
mutex->id, who);
return pthread_mutex_unlock (&mutex->mutex);
}
int xine_mutex_destroy (xine_mutex_t *mutex) {
return pthread_mutex_destroy (&mutex->mutex);
}
--- NEW FILE: xine_check.h ---
#ifndef XINE_CHECK_H
#define XINE_CHECK_H
#include <stdio.h>
#ifdef XINE_COMPILE
# include "xine.h"
#else
# include <xine.h>
#endif
/*
* Start checking xine setup here
*
* cdrom_dev = Name of the device link for the cdrom drive (e.g. /dev/cdrom)
* dvd_dev = Name of the device link for the dvd drive (e.g. /dev/dvd)
*/
/* Get Kernel information */
xine_health_check_t* _x_health_check_kernel(xine_health_check_t*);
/* health_check MTRR */
xine_health_check_t* _x_health_check_mtrr(xine_health_check_t*);
/* health_check CDROM */
xine_health_check_t* _x_health_check_cdrom(xine_health_check_t*);
/* health_check DVDROM */
xine_health_check_t* _x_health_check_dvdrom(xine_health_check_t*);
/* health_check DMA settings of DVD drive*/
xine_health_check_t* _x_health_check_dma(xine_health_check_t*);
/* health_check X */
xine_health_check_t* _x_health_check_x(xine_health_check_t*);
/* health_check Xv extension */
xine_health_check_t* _x_health_check_xv(xine_health_check_t*);
#endif
--- NEW FILE: copy.c ---
/*
* Copyright (C) 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id:
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "xineutils.h"
void yv12_to_yv12
(unsigned char *y_src, int y_src_pitch, unsigned char *y_dst, int y_dst_pitch,
unsigned char *u_src, int u_src_pitch, unsigned char *u_dst, int u_dst_pitch,
unsigned char *v_src, int v_src_pitch, unsigned char *v_dst, int v_dst_pitch,
int width, int height) {
int y, half_width = width / 2;
/* Y Plane */
if(y_src_pitch == y_dst_pitch)
xine_fast_memcpy(y_dst, y_src, y_src_pitch*height);
else {
for(y = 0; y < height; y++) {
xine_fast_memcpy(y_dst, y_src, width);
y_src += y_src_pitch;
y_dst += y_dst_pitch;
}
}
/* U/V Planes */
if((u_src_pitch == u_dst_pitch) && (v_src_pitch == v_dst_pitch)) {
xine_fast_memcpy(u_dst, u_src, u_src_pitch*height/2);
xine_fast_memcpy(v_dst, v_src, v_src_pitch*height/2);
} else {
for(y = 0; y < (height / 2); y++) {
xine_fast_memcpy(u_dst, u_src, half_width);
xine_fast_memcpy(v_dst, v_src, half_width);
u_src += u_src_pitch;
v_src += v_src_pitch;
u_dst += u_dst_pitch;
v_dst += v_dst_pitch;
}
}
}
void yuy2_to_yuy2
(unsigned char *src, int src_pitch,
unsigned char *dst, int dst_pitch,
int width, int height) {
int y, double_width = width * 2;
if(src_pitch == dst_pitch)
xine_fast_memcpy(dst, src, src_pitch*height);
else {
for(y = 0; y < height; y++) {
xine_fast_memcpy(dst, src, double_width);
src += src_pitch;
dst += dst_pitch;
}
}
}
--- NEW FILE: ppcasm_string.S ---
/*
* BK Id: SCCS/s.string.S 1.9 10/25/01 10:08:51 trini
*/
/*
* String handling functions for PowerPC.
*
* Copyright (C) 1996 Paul Mackerras.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*/
//#warning Be forewarned - using PowerPC assembly
#include "ppc_asm.tmpl"
#define N_FUN 36
#define N_SO 100
#define COPY_16_BYTES \
lwz r7,4(r4); \
lwz r8,8(r4); \
lwz r9,12(r4); \
lwzu r10,16(r4); \
stw r7,4(r6); \
stw r8,8(r6); \
stw r9,12(r6); \
stwu r10,16(r6)
#define __stringify_1(x) #x
#define __stringify(x) __stringify_1(x)
#define _GLOBFN(n)\
.stabs __stringify(n:F-1),N_FUN,0,0,n;\
.type n,@function; \
.globl n;\
n:
#define _SIZE(n) \
.size n, .-n
.text
.stabs "src/xine-utils",N_SO,0,0,.
.stabs "ppcasm_string.S",N_SO,0,0,.
#warning FIXME: Get cache line sizes from /proc
#define L1_CACHE_LINE_SIZE 32
CACHELINE_BYTES = 32
LG_CACHELINE_BYTES = 5
CACHELINE_MASK = (32 -1)
/*
* This version uses dcbz on the complete cache lines in the
* destination area to reduce memory traffic. This requires that
* the destination area is cacheable.
* We only use this version if the source and dest don't overlap.
* -- paulus.
*/
_GLOBFN(ppcasm_cacheable_memcpy)
add r7,r3,r5 /* test if the src & dst overlap */
add r8,r4,r5
cmplw 0,r4,r7
cmplw 1,r3,r8
crand 0,0,4 /* cr0.lt &= cr1.lt */
blt 66f //ppcasm_memcpy /* if regions overlap */
addi r4,r4,-4
addi r6,r3,-4
neg r0,r3
andi. r0,r0,CACHELINE_MASK /* # bytes to start of cache line */
beq 58f
cmplw 0,r5,r0 /* is this more than total to do? */
blt 63f /* if not much to do */
andi. r8,r0,3 /* get it word-aligned first */
subf r5,r0,r5
mtctr r8
beq+ 61f
70: lbz r9,4(r4) /* do some bytes */
stb r9,4(r6)
addi r4,r4,1
addi r6,r6,1
bdnz 70b
61: srwi. r0,r0,2
mtctr r0
beq 58f
72: lwzu r9,4(r4) /* do some words */
stwu r9,4(r6)
bdnz 72b
58: srwi. r0,r5,LG_CACHELINE_BYTES /* # complete cachelines */
clrlwi r5,r5,32-LG_CACHELINE_BYTES
li r11,4
mtctr r0
beq 63f
53:
#if !defined(CONFIG_8xx)
dcbz r11,r6
#endif
COPY_16_BYTES
#if L1_CACHE_LINE_SIZE >= 32
COPY_16_BYTES
#if L1_CACHE_LINE_SIZE >= 64
COPY_16_BYTES
COPY_16_BYTES
#if L1_CACHE_LINE_SIZE >= 128
COPY_16_BYTES
COPY_16_BYTES
COPY_16_BYTES
COPY_16_BYTES
#endif
#endif
#endif
bdnz 53b
63: srwi. r0,r5,2
mtctr r0
beq 64f
30: lwzu r0,4(r4)
stwu r0,4(r6)
bdnz 30b
64: andi. r0,r5,3
mtctr r0
beq+ 65f
40: lbz r0,4(r4)
stb r0,4(r6)
addi r4,r4,1
addi r6,r6,1
bdnz 40b
65: blr
_SIZE(ppcasm_cacheable_memcpy)
_GLOBFN(ppcasm_memcpy)
66: srwi. r7,r5,3
addi r6,r3,-4
addi r4,r4,-4
beq 2f /* if less than 8 bytes to do */
andi. r0,r6,3 /* get dest word aligned */
mtctr r7
bne 5f
1: lwz r7,4(r4)
lwzu r8,8(r4)
stw r7,4(r6)
stwu r8,8(r6)
bdnz 1b
andi. r5,r5,7
2: cmplwi 0,r5,4
blt 3f
lwzu r0,4(r4)
addi r5,r5,-4
stwu r0,4(r6)
3: cmpwi 0,r5,0
beqlr
mtctr r5
addi r4,r4,3
addi r6,r6,3
4: lbzu r0,1(r4)
stbu r0,1(r6)
bdnz 4b
blr
5: subfic r0,r0,4
mtctr r0
6: lbz r7,4(r4)
addi r4,r4,1
stb r7,4(r6)
addi r6,r6,1
bdnz 6b
subf r5,r0,r5
rlwinm. r7,r5,32-3,3,31
beq 2b
mtctr r7
b 1b
_SIZE(ppcasm_memcpy)
--- NEW FILE: xine_buffer.h ---
/*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id: xine_buffer.h,v 1.1 2005/04/04 22:38:34 dsalt-guest Exp $
*
*
* 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);
/*
* 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);
/*
* duplicates a buffer
*/
void *xine_buffer_dup(void *buf);
/*
* 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);
/*
* 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(void *buf, int index, void *data, int len);
/*
* 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);
/*
* concatnates given buf (which schould 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, char *data);
/*
* 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, char *data);
/*
* 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(void *buf, int ch);
/*
* get allocated memory size
*/
int xine_buffer_get_size(void *buf);
/*
* 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);
#endif
--- NEW FILE: xine_check.c ---
/*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* Xine Health Check:
*
* Overview: Checking the setup of the user's system is the task of
* xine-check.sh for now. At present this is intended to replace
* xine_check to provide a more robust way of informing users new
* to xine of the setup of their system.
*
* Interface: The function xine_health_check is the starting point
* to check the user's system. It is expected that the values for
* hc->cdrom_dev and hc->dvd_dev will be defined. For example,
* hc->cdrom_dev = /dev/cdrom and hc->/dev/dvd. If at any point a
* step fails the function returns with a failed status,
* XINE_HEALTH_CHECK_FAIL, and an error message contained in hc->msg.
*
* Author: Stephen Torri <storri@users.sourceforge.net>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include "xine_check.h"
#include "xineutils.h"
#if defined(__linux__)
#include <dlfcn.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/utsname.h>
#include <linux/major.h>
#include <linux/hdreg.h>
#ifdef HAVE_X11
# include <X11/Xlib.h>
# ifdef HAVE_XV
# include <X11/extensions/Xvlib.h>
# endif
#endif
#ifndef SCSI_BLK_MAJOR
#define SCSI_BLK_MAJOR(m) \
(((m) == SCSI_DISK0_MAJOR || \
((m) >= SCSI_DISK1_MAJOR && (m) <= SCSI_DISK7_MAJOR)) || \
((m) == SCSI_CDROM_MAJOR))
#endif
#endif /* !__linux__ */
static void set_hc_result(xine_health_check_t* hc, int state, char *format, ...) {
va_list args;
char *buf = NULL;
int n, size;
if (!hc) {
printf ("xine_check: GASP, hc is NULL\n");
_x_abort();
}
if (!format) {
printf ("xine_check: GASP, format is NULL\n");
_x_abort();
}
size = strlen(format) + 1;
if (!(buf = xine_xmalloc(size)))
_x_abort();
while(1) {
va_start(args, format);
n = vsnprintf(buf, size, format, args);
va_end(args);
if(n > -1 && n < size) {
break;
}
if(n > -1) {
size = n + 1;
}
else {
size *= 2;
}
if((buf = realloc(buf, size)) == NULL) {
printf("%s() GASP, realloc() failed\n", __XINE_FUNCTION__);
_x_abort();
}
}
hc->msg = buf;
hc->status = state;
}
#if defined(__linux__)
xine_health_check_t* xine_health_check (xine_health_check_t* hc, int check_num) {
switch(check_num) {
case CHECK_KERNEL:
hc = _x_health_check_kernel (hc);
break;
case CHECK_MTRR:
hc = _x_health_check_mtrr (hc);
break;
case CHECK_CDROM:
hc = _x_health_check_cdrom (hc);
break;
case CHECK_DVDROM:
hc = _x_health_check_dvdrom (hc);
break;
case CHECK_DMA:
hc = _x_health_check_dma (hc);
break;
case CHECK_X:
hc = _x_health_check_x (hc);
break;
case CHECK_XV:
hc = _x_health_check_xv (hc);
break;
default:
hc->status = XINE_HEALTH_CHECK_NO_SUCH_CHECK;
}
return hc;
}
xine_health_check_t* _x_health_check_kernel (xine_health_check_t* hc) {
struct utsname kernel;
hc->title = "Check for kernel version";
hc->explanation = "Probably you're not running a Linux-Like system.";
if (uname (&kernel) == 0) {
fprintf (stdout," sysname: %s\n", kernel.sysname);
fprintf (stdout," release: %s\n", kernel.release);
fprintf (stdout," machine: %s\n", kernel.machine);
hc->status = XINE_HEALTH_CHECK_OK;
}
else {
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL,
"FAILED - Could not get kernel information.");
}
return hc;
}
#if defined(ARCH_X86) || defined(ARCH_X86_64)
xine_health_check_t* _x_health_check_mtrr (xine_health_check_t* hc) {
char *file = "/proc/mtrr";
FILE *fd;
hc->title = "Check for MTRR support";
hc->explanation = "Make sure your kernel has MTRR support compiled in.";
fd = fopen(file, "r");
if (!fd) {
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL,
"FAILED: mtrr is not enabled.");
} else {
hc->status = XINE_HEALTH_CHECK_OK;
fclose (fd);
}
return hc;
}
#else
xine_health_check_t* _x_health_check_mtrr (xine_health_check_t* hc) {
hc->title = "Check for MTRR support";
hc->explanation = "Don't worry about this one";
set_hc_result (hc, XINE_HEALTH_CHECK_OK,
"mtrr does not apply on this hw platform.");
return hc;
}
#endif
xine_health_check_t* _x_health_check_cdrom (xine_health_check_t* hc) {
struct stat cdrom_st;
int fd;
hc->title = "Check for CDROM drive";
hc->explanation = "Either create a symbolic link /dev/cdrom pointing to"
"your cdrom device or set your cdrom device in the"
"preferences dialog.";
if (stat (hc->cdrom_dev,&cdrom_st) < 0) {
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "FAILED - could not access cdrom: %s\n", hc->cdrom_dev);
return hc;
}
if ((cdrom_st.st_mode & S_IFMT) != S_IFBLK) {
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "FAILED - %s is not a block device.\n", hc->cdrom_dev);
return hc;
}
if ( (fd = open(hc->cdrom_dev, O_RDWR)) < 0) {
switch (errno) {
case EACCES:
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "FAILED - %s permissions are not sufficient\n.", hc->cdrom_dev);
return hc;
case ENXIO:
case ENODEV:
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "FAILED - there is no device behind %s\n.", hc->cdrom_dev);
return hc;
}
} else
close(fd);
hc->status = XINE_HEALTH_CHECK_OK;
return hc;
}
xine_health_check_t* _x_health_check_dvdrom(xine_health_check_t* hc) {
struct stat dvdrom_st;
int fd;
hc->title = "Check for DVD drive";
hc->explanation = "Either create a symbolic link /dev/dvd pointing to"
"your cdrom device or set your cdrom device in the"
"preferences dialog.";
if (stat (hc->dvd_dev,&dvdrom_st) < 0) {
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "FAILED - could not access dvdrom: %s\n", hc->dvd_dev);
return hc;
}
if ((dvdrom_st.st_mode & S_IFMT) != S_IFBLK) {
set_hc_result(hc, XINE_HEALTH_CHECK_FAIL, "FAILED - %s is not a block device.\n", hc->dvd_dev);
return hc;
}
if ( (fd = open(hc->dvd_dev, O_RDWR)) < 0) {
switch (errno) {
case EACCES:
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "FAILED - %s permissions are not sufficient\n.", hc->dvd_dev);
return hc;
case ENXIO:
case ENODEV:
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "FAILED - there is no device behind %s\n.", hc->dvd_dev);
return hc;
}
} else
close(fd);
hc->status = XINE_HEALTH_CHECK_OK;
return hc;
}
xine_health_check_t* _x_health_check_dma (xine_health_check_t* hc) {
int is_scsi_dev = 0;
int fd = 0;
static long param = 0;
struct stat st;
hc->title = "Check for DMA mode on DVD drive";
hc->explanation = "If you are using the ide-cd module ensure\n"
"that you have the following entry in /etc/modules.conf:\n"
"options ide-cd dma=1\n Reload ide-cd module.\n"
"otherwise run hdparm -d 1 on your dvd-device.";
/* If /dev/dvd points to /dev/scd0 but the drive is IDE (e.g. /dev/hdc)
* and not scsi how do we detect the correct one */
if (stat (hc->dvd_dev, &st)) {
set_hc_result(hc, XINE_HEALTH_CHECK_FAIL, "FAILED - Could not read stats for %s.\n", hc->dvd_dev);
return hc;
}
if (SCSI_BLK_MAJOR(major(st.st_rdev))) {
is_scsi_dev = 1;
set_hc_result(hc, XINE_HEALTH_CHECK_OK, "SKIPPED - Operation not supported on SCSI drives or drives that use the ide-scsi module.");
return hc;
}
fd = open (hc->dvd_dev, O_RDONLY | O_NONBLOCK);
if (fd < 0) {
set_hc_result(hc, XINE_HEALTH_CHECK_FAIL, "FAILED - Could not open %s.\n", hc->dvd_dev);
return hc;
}
if (!is_scsi_dev) {
if(ioctl (fd, HDIO_GET_DMA, ¶m)) {
set_hc_result(hc, XINE_HEALTH_CHECK_FAIL,
"FAILED - HDIO_GET_DMA failed. Ensure the permissions for %s are 0664.\n",
hc->dvd_dev);
return hc;
}
if (param != 1) {
set_hc_result(hc, XINE_HEALTH_CHECK_FAIL,
"FAILED - DMA not turned on for %s.",
hc->dvd_dev);
return hc;
}
}
close (fd);
hc->status = XINE_HEALTH_CHECK_OK;
return hc;
}
xine_health_check_t* _x_health_check_x (xine_health_check_t* hc) {
char* env_display = getenv("DISPLAY");
hc->title = "Check for X11 environment";
hc->explanation = "Make sure you're running X11, if this is an ssh connection,\n"
"make sure you have X11 forwarding enabled (ssh -X ...)";
if (strlen (env_display) == 0) {
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "FAILED - DISPLAY environment variable not set.");
}
else {
hc->status = XINE_HEALTH_CHECK_OK;
}
return hc;
}
xine_health_check_t* _x_health_check_xv (xine_health_check_t* hc) {
#ifdef HAVE_X11
#ifdef HAVE_XV
Display *dpy;
unsigned int ver, rev, eventB, reqB, errorB;
char *disname = NULL;
void *x11_handle;
void *xv_handle;
Display *(*xopendisplay)(char*);
char *(*xdisplayname)(char*);
int (*xvqueryextension)(Display*, unsigned int*, unsigned int*, unsigned int*, unsigned int*, unsigned int*);
int (*xvqueryadaptors)(Display*, Window, unsigned int*, XvAdaptorInfo**);
XvImageFormatValues *(*xvlistimageformats)(Display*, XvPortID, int*);
char *err = NULL;
int formats, adaptors, i;
XvImageFormatValues *img_formats;
XvAdaptorInfo *adaptor_info;
hc->title = "Check for MIT Xv extension";
hc->explanation = "You can improve performance by installing an X11\n"
"driver that supports the Xv protocol extentsion.";
/* Majority of thi code was taken from or inspired by the xvinfo.c file of XFree86 */
dlerror(); /* clear error code */
x11_handle = dlopen("libX11.so", RTLD_LAZY);
if(!x11_handle) {
hc->msg = dlerror();
hc->status = XINE_HEALTH_CHECK_FAIL;
return hc;
}
/* Get reference to XOpenDisplay */
xopendisplay = dlsym(x11_handle,"XOpenDisplay");
if((err = dlerror()) != NULL) {
hc->msg = err;
hc->status = XINE_HEALTH_CHECK_FAIL;
dlclose(x11_handle);
return hc;
}
/* Get reference to XDisplayName */
xdisplayname = dlsym(x11_handle,"XDisplayName");
if((err = dlerror()) != NULL) {
hc->msg = err;
hc->status = XINE_HEALTH_CHECK_FAIL;
dlclose(x11_handle);
return hc;
}
dlerror(); /* clear error code */
xv_handle = dlopen("libXv.so", RTLD_LAZY);
if(!xv_handle) {
hc->msg = dlerror();
/* Xv might still work when linked statically into the output plugin,
* so reporting FAIL would be wrong here */
hc->status = XINE_HEALTH_CHECK_UNSUPPORTED;
dlclose(x11_handle);
return hc;
}
/* Get reference to XvQueryExtension */
xvqueryextension = dlsym(xv_handle,"XvQueryExtension");
if((err = dlerror()) != NULL) {
hc->msg = err;
hc->status = XINE_HEALTH_CHECK_FAIL;
dlclose(x11_handle);
dlclose(xv_handle);
return hc;
}
/* Get reference to XvQueryAdaptors */
xvqueryadaptors = dlsym(xv_handle,"XvQueryAdaptors");
if((err = dlerror()) != NULL) {
hc->msg = err;
hc->status = XINE_HEALTH_CHECK_FAIL;
dlclose(x11_handle);
dlclose(xv_handle);
return hc;
}
/* Get reference to XvListImageFormats */
xvlistimageformats = dlsym(xv_handle,"XvListImageFormats");
if((err = dlerror()) != NULL) {
hc->msg = err;
hc->status = XINE_HEALTH_CHECK_FAIL;
dlclose(x11_handle);
dlclose(xv_handle);
return hc;
}
if(!(dpy = (*xopendisplay)(disname))) {
if (!disname) {
disname = (*xdisplayname)(NULL);
}
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "Unable to open display: %s\n", disname);
dlclose(x11_handle);
dlclose(xv_handle);
return hc;
}
if((Success != xvqueryextension(dpy, &ver, &rev, &reqB, &eventB, &errorB))) {
if (!disname) {
disname = xdisplayname(NULL);
}
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "Unable to open display: %s\n",disname);
dlclose(x11_handle);
dlclose(xv_handle);
return hc;
}
else {
printf("X-Video Extension version %d.%d\n", ver, rev);
}
/*
* check adaptors, search for one that supports (at least) yuv12
*/
if (Success != xvqueryadaptors(dpy,DefaultRootWindow(dpy),
&adaptors,&adaptor_info)) {
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "video_out_xv: XvQueryAdaptors failed.\n");
dlclose(x11_handle);
dlclose(xv_handle);
return hc;
}
if (!adaptor_info) {
set_hc_result (hc, XINE_HEALTH_CHECK_FAIL, "video_out_xv: No adaptors found.\n");
dlclose(x11_handle);
dlclose(xv_handle);
return hc;
}
img_formats = xvlistimageformats (dpy, adaptor_info->base_id, &formats);
for(i = 0; i < formats; i++) {
printf ("video_out_xv: Xv image format: 0x%x (%4.4s) %s\n",
img_formats[i].id, (char*)&img_formats[i].id,
(img_formats[i].format == XvPacked) ? "packed" : "planar");
if (img_formats[i].id == XINE_IMGFMT_YV12) {
printf("video_out_xv: this adaptor supports the yv12 format.\n");
set_hc_result (hc, XINE_HEALTH_CHECK_OK, "video_out_xv: this adaptor supports the yv12 format.\n");
} else if (img_formats[i].id == XINE_IMGFMT_YUY2) {
printf("video_out_xv: this adaptor supports the yuy2 format.\n");
set_hc_result (hc, XINE_HEALTH_CHECK_OK, "video_out_xv: this adaptor supports the yuy2 format.\n");
}
}
dlclose(x11_handle);
dlclose(xv_handle);
return hc;
#else
hc->title = "Check for MIT Xv extension";
hc->explanation = "You can improve performance by installing an X11\n"
"driver that supports the Xv protocol extentsion.";
set_hc_result(hc, XINE_HEALTH_CHECK_FAIL, "No X-Video Extension was present at compile time");
return hc;
#endif /* ! HAVE_HV */
#else
hc->title = "Check for MIT Xv extension";
hc->explanation = "You can improve performance by installing an X11\n"
"driver that supports the Xv protocol extentsion.";
set_hc_result(hc, XINE_HEALTH_CHECK_FAIL, "No X11 windowing system was present at compile time");
return hc;
#endif /* ! HAVE_X11 */
}
#else /* !__linux__ */
xine_health_check_t* xine_health_check (xine_health_check_t* hc, int check_num) {
hc->title = "xine health check not supported on this platform";
hc->explanation = "contact the xine-devel mailing list if you'd like to\n"
"contribute code for your platform.";
set_hc_result(hc, XINE_HEALTH_CHECK_NO_SUCH_CHECK,
"xine health check not supported on the OS.\n");
return hc;
}
#endif /* !__linux__ */
--- NEW FILE: compat.h ---
/*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id: compat.h,v 1.1 2005/04/04 22:38:34 dsalt-guest Exp $
*
*/
#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
--- NEW FILE: xine_buffer.c ---
/*
* Copyright (C) 2000-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id: xine_buffer.c,v 1.1 2005/04/04 22:38:34 dsalt-guest Exp $
*
*
* 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.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#define LOG_MODULE "xine_buffer"
#define LOG_VERBOSE
/*
#define LOG
*/
#include "xineutils.h"
#define CHECKS
/*
* private data structs
*/
typedef struct {
uint32_t size;
uint32_t chunk_size;
uint8_t magic;
} xine_buffer_header_t;
#define XINE_BUFFER_HEADER_SIZE 9
#define XINE_BUFFER_MAGIC 42
/*
* xine_buffer stores its additional info just in front of
* the public data pointer:
*
* <header 8 bytes> <magic 1 byte> <data>
* ^public pointer
*
* hopefully the magic value will prevent some segfaults,
* if xine_buffer_* functions are called with user-malloced
* data chunks...
*/
/*
* some macros
*/
#define CHECK_MAGIC(x) if (*(((uint8_t *)x)-1)!=XINE_BUFFER_MAGIC) \
{printf("xine_buffer: FATAL: xine_buffer_header not recognized!\n");exit(1);}
#define GET_HEADER(x) ((xine_buffer_header_t*)(((uint8_t*)x)-XINE_BUFFER_HEADER_SIZE))
/* reallocs buf, if smaller than size. */
#define GROW_TO(buf, to_size) \
if (GET_HEADER(buf)->size < (to_size)) { \
int new_size = (to_size) + GET_HEADER(buf)->chunk_size - \
((to_size) % GET_HEADER(buf)->chunk_size);\
\
buf = ((uint8_t*)realloc(((uint8_t*)buf)-XINE_BUFFER_HEADER_SIZE, new_size+XINE_BUFFER_HEADER_SIZE)) + XINE_BUFFER_HEADER_SIZE;\
GET_HEADER(buf)->size=new_size; }
/*
* 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) {
uint8_t *data=xine_xmalloc(chunk_size+XINE_BUFFER_HEADER_SIZE);
xine_buffer_header_t *header=(xine_buffer_header_t*)data;
header->size=chunk_size;
header->chunk_size=chunk_size;
header->magic=XINE_BUFFER_MAGIC;
return data+XINE_BUFFER_HEADER_SIZE;
}
/*
* 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) {
#ifdef CHECKS
if (!buf) {
lprintf("warning: got NULL pointer\n");
return NULL;
}
CHECK_MAGIC(buf);
#endif
free(((uint8_t*)buf)-XINE_BUFFER_HEADER_SIZE);
return NULL;
}
/*
* duplicates a buffer
*/
void *xine_buffer_dup(void *buf) {
uint8_t *new;
#ifdef CHECKS
if (!buf) {
lprintf("warning: got NULL pointer\n");
return NULL;
}
CHECK_MAGIC(buf);
#endif
new=xine_xmalloc(GET_HEADER(buf)->size+XINE_BUFFER_HEADER_SIZE);
xine_fast_memcpy(new, ((uint8_t*)buf)-XINE_BUFFER_HEADER_SIZE,
GET_HEADER(buf)->size+XINE_BUFFER_HEADER_SIZE);
return new+XINE_BUFFER_HEADER_SIZE;
}
/*
* 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) {
#ifdef CHECKS
if (!buf || !data) {
lprintf("warning: got NULL pointer\n");
return NULL;
}
CHECK_MAGIC(buf);
#endif
GROW_TO(buf, index+len);
xine_fast_memcpy(((uint8_t*)buf)+index, data, len);
return buf;
}
/*
* 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(void *buf, int index, void *data, int len) {
#ifdef CHECKS
if (!buf || !data) {
lprintf("warning: got NULL pointer\n");
return;
}
CHECK_MAGIC(buf);
#endif
if (GET_HEADER(buf)->size < index+len)
{
lprintf("warning: attempt to read over boundary!\n");
if (GET_HEADER(buf)->size < index)
return;
len = GET_HEADER(buf)->size - index;
}
xine_fast_memcpy(data, ((uint8_t*)buf)+index, len);
}
/*
* 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) {
#ifdef CHECKS
if (!buf) {
lprintf("warning: got NULL pointer\n");
return NULL;
}
CHECK_MAGIC(buf);
#endif
GROW_TO(buf, index+len);
memset(((uint8_t*)buf)+index, b, len);
return buf;
}
/*
* concatnates given buf (which schould 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, char *data) {
#ifdef CHECKS
if (!buf || !data) {
lprintf("warning: got NULL pointer\n");
return NULL;
}
CHECK_MAGIC(buf);
#endif
GROW_TO(buf, strlen(buf)+strlen(data)+1);
strcat(buf, data);
return buf;
}
/*
* 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, char *data) {
#ifdef CHECKS
if (!buf || !data) {
lprintf("warning: got NULL pointer\n");
return NULL;
}
CHECK_MAGIC(buf);
#endif
GROW_TO(buf, index+strlen(data)+1);
strcpy(((char*)buf)+index, data);
return buf;
}
/*
* returns a pointer to the first occurence of needle.
* note, that the returned pointer cannot be used
* in any other xine_buffer_* functions.
*/
char *xine_buffer_strchr(void *buf, int ch) {
#ifdef CHECKS
if (!buf) {
lprintf("warning: got NULL pointer\n");
return 0;
}
CHECK_MAGIC(buf);
#endif
return strchr((const char *)buf, ch);
}
/*
* get allocated memory size
*/
int xine_buffer_get_size(void *buf) {
#ifdef CHECKS
if (!buf) {
lprintf("warning: got NULL pointer\n");
return 0;
}
CHECK_MAGIC(buf);
#endif
return GET_HEADER(buf)->size;
}
/*
* 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) {
#ifdef CHECKS
if (!buf) {
lprintf("warning: got NULL pointer\n");
return 0;
}
CHECK_MAGIC(buf);
#endif
GROW_TO(buf, size);
return buf;
}
--- NEW FILE: monitor.c ---
/*
* Copyright (C) 2000-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id: monitor.c,v 1.1 2005/04/04 22:38:34 dsalt-guest Exp $
*
* debug print and profiling functions - implementation
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <sys/time.h>
#include "xineutils.h"
#define MAX_ID 10
#ifdef DEBUG
long long int profiler_times[MAX_ID] ;
long long int profiler_start[MAX_ID] ;
long profiler_calls[MAX_ID] ;
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;
}
}
int xine_profiler_allocate_slot (char *label) {
int id;
for (id = 0; id < MAX_ID && profiler_label[id] != NULL; id++)
;
if (id >= MAX_ID)
return -1;
profiler_label[id] = label;
return id;
}
#if defined(ARCH_X86) || defined(ARCH_X86_64)
__inline__ unsigned long long int rdtsc()
{
unsigned long long int x;
__asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
return x;
}
#endif
void xine_profiler_start_count (int id) {
if ((unsigned)id >= MAX_ID) return;
#if defined(ARCH_X86) || defined(ARCH_X86_64)
profiler_start[id] = rdtsc();
#endif
}
void xine_profiler_stop_count (int id) {
if ((unsigned)id >= MAX_ID) return;
#if defined(ARCH_X86) || defined(ARCH_X86_64)
profiler_times[id] += rdtsc() - profiler_start[id];
#endif
profiler_calls[id]++;
}
void xine_profiler_print_results () {
int i;
#if defined(ARCH_X86) || defined(ARCH_X86_64)
static long long int cpu_speed; /* cpu cyles/usec */
if (!cpu_speed) {
long long int tsc_start, tsc_end;
struct timeval tv_start, tv_end;
tsc_start = rdtsc();
gettimeofday(&tv_start, NULL);
xine_usec_sleep(100000);
tsc_end = rdtsc();
gettimeofday(&tv_end, NULL);
cpu_speed = (tsc_end - tsc_start) /
((tv_end.tv_sec - tv_start.tv_sec) * 1e6 +
tv_end.tv_usec - tv_start.tv_usec);
}
#endif
printf ("\n\nPerformance analysis:\n\n"
"%-3s %-24.24s %12s %9s %12s %9s\n"
"----------------------------------------------------------------------------\n",
"ID", "name", "cpu cycles", "calls", "cycles/call", "usec/call");
for (i=0; i<MAX_ID; i++) {
if (profiler_label[i]) {
printf ("%2d: %-24.24s %12lld %9ld",
i, profiler_label[i], profiler_times[i], profiler_calls[i]);
if (profiler_calls[i]) {
printf(" %12lld", profiler_times[i] / profiler_calls[i]);
#if defined(ARCH_X86) || defined(ARCH_X86_64)
printf(" %9lld", profiler_times[i] / (cpu_speed * profiler_calls[i]));
#endif
}
printf ("\n");
}
}
}
#else /* DEBUG */
#define NO_PROFILER_MSG {printf("xine's profiler is unavailable.\n");}
/* Dummies */
void xine_profiler_init (void) {
NO_PROFILER_MSG
}
int xine_profiler_allocate_slot (char *label) {
return -1;
}
void xine_profiler_start_count (int id) {
}
void xine_profiler_stop_count (int id) {
}
void xine_profiler_print_results (void) {
NO_PROFILER_MSG
}
#endif
--- NEW FILE: color.c ---
/*
* Copyright (C) 2000-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
[...1119 lines suppressed...]
yv12_to_yuy2 = yv12_to_yuy2_mmxext;
else
yv12_to_yuy2 = yv12_to_yuy2_c;
/* determine best YV12 -> YUY2 converter to use */
if (xine_mm_accel() & MM_ACCEL_X86_MMXEXT)
yuy2_to_yv12 = yuy2_to_yv12_mmxext;
else
yuy2_to_yv12 = yuy2_to_yv12_c;
/* determine best YUV9 -> YV12 converter to use (only the portable C
* version is available so far) */
yuv9_to_yv12 = yuv9_to_yv12_c;
/* determine best YUV411 -> YV12 converter to use (only the portable C
* version is available so far) */
yuv411_to_yv12 = yuv411_to_yv12_c;
}
--- NEW FILE: ppc_asm.tmpl ---
/* Condition Register Bit Fields */
#define cr0 0
#define cr1 1
#define cr2 2
#define cr3 3
#define cr4 4
#define cr5 5
#define cr6 6
#define cr7 7
/* General Purpose Registers (GPRs) */
#define r0 0
#define r1 1
#define r2 2
#define r3 3
#define r4 4
#define r5 5
#define r6 6
#define r7 7
#define r8 8
#define r9 9
#define r10 10
#define r11 11
#define r12 12
#define r13 13
#define r14 14
#define r15 15
#define r16 16
#define r17 17
#define r18 18
#define r19 19
#define r20 20
#define r21 21
#define r22 22
#define r23 23
#define r24 24
#define r25 25
#define r26 26
#define r27 27
#define r28 28
#define r29 29
#define r30 30
#define r31 31
/* Floating Point Registers (FPRs) */
#define fr0 0
#define fr1 1
#define fr2 2
#define fr3 3
#define fr4 4
#define fr5 5
#define fr6 6
#define fr7 7
#define fr8 8
#define fr9 9
#define fr10 10
#define fr11 11
#define fr12 12
#define fr13 13
#define fr14 14
#define fr15 15
#define fr16 16
#define fr17 17
#define fr18 18
#define fr19 19
#define fr20 20
#define fr21 21
#define fr22 22
#define fr23 23
#define fr24 24
#define fr25 25
#define fr26 26
#define fr27 27
#define fr28 28
#define fr29 29
#define fr30 30
#define fr31 31
#define vr0 0
#define vr1 1
#define vr2 2
#define vr3 3
#define vr4 4
#define vr5 5
#define vr6 6
#define vr7 7
#define vr8 8
#define vr9 9
#define vr10 10
#define vr11 11
#define vr12 12
#define vr13 13
#define vr14 14
#define vr15 15
#define vr16 16
#define vr17 17
#define vr18 18
#define vr19 19
#define vr20 20
#define vr21 21
#define vr22 22
#define vr23 23
#define vr24 24
#define vr25 25
#define vr26 26
#define vr27 27
#define vr28 28
#define vr29 29
#define vr30 30
#define vr31 31
--- NEW FILE: utils.c ---
/*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id: utils.c,v 1.1 2005/04/04 22:38:34 dsalt-guest Exp $
*
*/
#define _POSIX_PTHREAD_SEMANTICS 1 /* for 5-arg getpwuid_r on solaris */
/*
#define LOG
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "xineutils.h"
#include "xineintl.h"
#ifdef _MSC_VER
#include "xine_internal.h"
#endif
#include <errno.h>
#include <pwd.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
#if HAVE_EXECINFO_H
#include <execinfo.h>
#endif
#if HAVE_UCONTEXT_H
#include <ucontext.h>
#endif
#ifdef HAVE_LANGINFO_CODESET
#include <langinfo.h>
#endif
#if defined(__CYGWIN__) || defined(WIN32)
#include <windows.h>
#endif
typedef struct {
char *language; /* name of the locale */
char *encoding; /* typical encoding */
char *spu_encoding; /* default spu encoding */
char *modifier;
} lang_locale_t;
/*
* information about locales used in xine
*/
static 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 },
{ "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 },
{ "de_AT", "iso-8859-15", "iso-8859-15", "euro" },
{ "de_BE", "iso-8859-1", "iso-8859-1", NULL },
{ "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_DE", "iso-8859-15", "iso-8859-15", "euro" },
{ "de_LU", "iso-8859-1", "iso-8859-1", NULL },
{ "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 },
{ "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 },
{ "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 },
{ "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 },
{ "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 },
{ "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_FR", "iso-8859-15", "iso-8859-15", "euro" },
{ "fr_LU", "iso-8859-1", "iso-8859-1", NULL },
{ "fr_LU", "iso-8859-15", "iso-8859-15", "euro" },
{ "ga_IE", "iso-8859-1", "iso-8859-1", NULL },
{ "ga_IE", "iso-8859-15", "iso-8859-15", "euro" },
{ "gl_ES", "iso-8859-1", "iso-8859-1", NULL },
{ "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 },
{ "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 },
{ "nl_BE", "iso-8859-15", "iso-8859-15", "euro" },
{ "nl_NL", "iso-8859-1", "iso-8859-1", NULL },
{ "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 },
{ "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 },
{ "sr_YU", "iso-8859-5", "cp1251", "cyrillic" },
{ "sv_FI", "iso-8859-1", "iso-8859-1", NULL },
{ "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 },
{ "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 }
};
void *xine_xmalloc(size_t size) {
void *ptr;
/* prevent xine_xmalloc(0) of possibly returning NULL */
if( !size )
size++;
if((ptr = calloc(1, size)) == NULL) {
fprintf(stderr, "%s: malloc() 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;
*base = ptr = xine_xmalloc (size+alignment);
while ((size_t) ptr % alignment)
ptr++;
return ptr;
}
#if defined(__CYGWIN__) || defined(WIN32)
/* Ridiculous hack to return valid xine support
* directories. These should be read from
* a registry entry set at install time.
*/
char *exec_path_append_subdir(char *string) {
static char tmp_win32_path[1024] = "\0";
char *back_slash;
char *fore_slash;
char *last_slash;
/* first run - fill out dll path */
if (!*tmp_win32_path) {
char *tmpchar;
char *cmdline;
/* get program exec command line */
cmdline = GetCommandLine();
/* check for " at beginning of string */
if( *cmdline == '\"' ) {
/* copy command line, skip first quote */
strncpy(tmp_win32_path, cmdline + 1, sizeof(tmp_win32_path));
tmp_win32_path[sizeof(tmp_win32_path) - 1] = '\0';
/* terminate at second set of quotes */
tmpchar = strchr(tmp_win32_path, '\"');
if (tmpchar) *tmpchar = 0;
} else {
/* copy command line */
strncpy(tmp_win32_path, cmdline, sizeof(tmp_win32_path));
tmp_win32_path[sizeof(tmp_win32_path) - 1] = '\0';
/* terminate at first space */
tmpchar = strchr(tmp_win32_path, ' ');
if (tmpchar) *tmpchar = 0;
}
}
/* find the last occurance of a back
* slash or fore slash
*/
back_slash = strrchr(tmp_win32_path, '\\');
fore_slash = strrchr(tmp_win32_path, '/');
/* make sure the last back slash was not
* after a drive letter
*/
if(back_slash > tmp_win32_path)
if(*( back_slash - 1 ) == ':')
back_slash = 0;
/* which slash was the latter slash */
if(back_slash > fore_slash)
last_slash = back_slash;
else
last_slash = fore_slash;
/* detect if we had a relative or
* distiguished path ( had a slash )
*/
if(last_slash) {
/* we had a slash charachter in our
* command line
*/
*(last_slash + 1) = 0;
/* if had a string to append to the path */
if(string)
strncat(tmp_win32_path, string, sizeof(tmp_win32_path) - strlen(tmp_win32_path) - 1);
} else {
if(string) {
/* if had a string to append to the path */
strncpy(tmp_win32_path, string, sizeof(tmp_win32_path));
tmp_win32_path[sizeof(tmp_win32_path) - 1] = '\0';
} else {
/* no slash, assume local directory */
strcpy(tmp_win32_path, ".");
}
}
return tmp_win32_path;
}
#endif
#ifndef BUFSIZ
#define BUFSIZ 256
#endif
const char *xine_get_homedir(void) {
#ifdef WIN32
return exec_path_append_subdir(NULL);
#else
struct passwd pwd, *pw = NULL;
static char homedir[BUFSIZ] = {0,};
if(homedir[0])
return homedir;
#ifdef HAVE_GETPWUID_R
if(getpwuid_r(getuid(), &pwd, homedir, sizeof(homedir), &pw) != 0 || pw == NULL) {
#else
if((pw = getpwuid(getuid())) == NULL) {
#endif
char *tmp = getenv("HOME");
if(tmp) {
strncpy(homedir, tmp, sizeof(homedir));
homedir[sizeof(homedir) - 1] = '\0';
}
} else {
char *s = strdup(pw->pw_dir);
strncpy(homedir, s, sizeof(homedir));
homedir[sizeof(homedir) - 1] = '\0';
free(s);
}
if(!homedir[0]) {
printf("xine_get_homedir: Unable to get home directory, set it to /tmp.\n");
strcpy(homedir, "/tmp");
}
return homedir;
#endif /* _MSC_VER */
}
char *xine_chomp(char *str) {
char *pbuf;
pbuf = str;
while(*pbuf != '\0') pbuf++;
while(pbuf > str) {
if(*pbuf == '\r' || *pbuf == '\n' || *pbuf == '"') pbuf = '\0';
pbuf--;
}
while(*pbuf == '=' || *pbuf == '"') pbuf++;
return pbuf;
}
/*
* a thread-safe usecond sleep
*/
void xine_usec_sleep(unsigned usec) {
#if HAVE_NANOSLEEP
/* nanosleep is prefered on solaris, because it's mt-safe */
struct timespec ts;
ts.tv_sec = usec / 1000000;
ts.tv_nsec = (usec % 1000000) * 1000;
nanosleep(&ts, NULL);
#else
# if WIN32
Sleep(usec / 1000);
# else
usleep(usec);
# endif
#endif
}
/* 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;
/* printf ("Hexdump: %i Bytes\n", length);*/
for(j=0; j<69; j++)
printf ("-");
printf ("\n");
j=0;
while(j<length) {
printf ("%04X ",j);
for (i=j; i<j+16; i++) {
if( i<length )
printf ("%02X ", (unsigned char) buf[i]);
else
printf(" ");
}
for (i=j;i<(j+16<length?j+16:length);i++) {
c=buf[i];
if ((c>=32) && (c<127))
printf ("%c", c);
else
printf (".");
}
j=i;
printf("\n");
}
for(j=0; j<69; j++)
printf("-");
printf("\n");
}
static const lang_locale_t *_get_first_lang_locale(char *lcal) {
const lang_locale_t *llocale;
if(lcal && strlen(lcal)) {
llocale = &*lang_locales;
while(llocale->language) {
if(!strncmp(lcal, llocale->language, strlen(lcal)))
return llocale;
llocale++;
}
}
return NULL;
}
static char *_get_lang(void) {
char *lang;
if(!(lang = getenv("LC_ALL")))
if(!(lang = getenv("LC_MESSAGES")))
lang = getenv("LANG");
return lang;
}
/*
* get encoding of current locale
*/
char *xine_get_system_encoding(void) {
char *codeset = NULL;
#ifdef HAVE_LANGINFO_CODESET
codeset = nl_langinfo(CODESET);
#endif
/*
* guess locale codeset according to shell variables
* when nl_langinfo(CODESET) isn't available or workig
*/
if (!codeset || strstr(codeset, "ANSI") != 0) {
char *lang = _get_lang();
codeset = NULL;
if(lang) {
char *lg, *enc, *mod;
lg = strdup(lang);
if((enc = strchr(lg, '.')) && (strlen(enc) > 1)) {
enc++;
if((mod = strchr(enc, '@')))
*mod = '\0';
codeset = strdup(enc);
}
else {
const lang_locale_t *llocale = _get_first_lang_locale(lg);
if(llocale && llocale->encoding)
codeset = strdup(llocale->encoding);
}
free(lg);
}
} else
codeset = strdup(codeset);
return codeset;
}
/*
* guess default encoding of subtitles
*/
const char *xine_guess_spu_encoding(void) {
char *lang = _get_lang();
if (lang) {
const lang_locale_t *llocale;
char *lg, *enc;
lg = strdup(lang);
if ((enc = strchr(lg, '.'))) *enc = '\0';
llocale = _get_first_lang_locale(lg);
free(lg);
if (llocale && llocale->spu_encoding) return llocale->spu_encoding;
}
return "iso-8859-1";
}
#ifdef _MSC_VER
void xine_xprintf(xine_t *xine, int verbose, const char *fmt, ...) {
char message[256];
va_list ap;
if (xine && xine->verbosity >= verbose) {
va_start(ap, fmt);
vsnprintf(message, sizeof(message), fmt, ap);
va_end(ap);
xine_log(xine, XINE_LOG_TRACE, "%s", message);
}
}
#endif
int xine_monotonic_clock(struct timeval *tv, struct timezone *tz)
{
#if _POSIX_TIMERS > 0 && defined(_POSIX_MONOTONIC_CLOCK) && defined(HAVE_POSIX_TIMERS)
static int initialized = 0;
static int use_clock_monotonic = 0;
struct timespec tp;
if( !initialized ) {
struct timespec res;
int ret;
ret = clock_getres(CLOCK_MONOTONIC, &res);
if( ret != 0 ) {
lprintf("get resolution of monotonic clock failed\n");
} else {
/* require at least milisecond resolution */
if( res.tv_sec > 0 ||
res.tv_nsec > 1000000 ) {
lprintf("monotonic clock resolution (%d:%d) too bad\n",
(int)res.tv_sec, (int)res.tv_nsec);
} else {
if( clock_gettime(CLOCK_MONOTONIC, &tp) != 0 ) {
lprintf("get monotonic clock failed\n");
} else {
lprintf("using monotonic clock\n");
use_clock_monotonic = 1;
}
}
}
initialized = 1;
}
if(use_clock_monotonic && !clock_gettime(CLOCK_MONOTONIC, &tp)) {
tv->tv_sec = tp.tv_sec;
tv->tv_usec = tp.tv_nsec / 1000;
return 0;
} else {
return gettimeofday(tv, tz);
}
#else
return gettimeofday(tv, tz);
#endif
}
--- NEW FILE: xmlparser.h ---
/*
* Copyright (C) 2002-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id: xmlparser.h,v 1.1 2005/04/04 22:38:34 dsalt-guest Exp $
*
*/
#ifndef XML_PARSER_H
#define XML_PARSER_H
/* 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(char * buf, int size, int mode);
int xml_parser_build_tree(xml_node_t **root_node);
void xml_parser_free_tree(xml_node_t *root_node);
char *xml_parser_get_property (xml_node_t *node, const char *name);
int xml_parser_get_property_int (xml_node_t *node, const char *name,
int def_value);
int xml_parser_get_property_bool (xml_node_t *node, const char *name,
int def_value);
/* for debugging purposes: dump read-in xml tree in a nicely
* indented fashion
*/
void xml_parser_dump_tree (xml_node_t *node) ;
#endif
--- NEW FILE: Makefile.am ---
include $(top_srcdir)/misc/Makefile.common
LIBTOOL = $(SHELL) $(top_builddir)/libtool
noinst_LTLIBRARIES = libxineutils.la
EXTRA_DIST = ppcasm_string.S ppc_asm.tmpl
if PPC_ARCH
if !HOST_OS_DARWIN
pppc_files = ppcasm_string.S
endif
endif
AM_CFLAGS = $(X_CFLAGS)
libxineutils_la_SOURCES = $(pppc_files) \
cpu_accel.c \
color.c \
copy.c \
list.c \
memcpy.c \
monitor.c \
utils.c \
xine_check.c \
xine_mutex.c \
xmllexer.c \
xine_buffer.c \
xmlparser.c
include_HEADERS = \
attributes.h \
compat.h \
xine_buffer.h \
xineutils.h \
xmllexer.h \
xmlparser.h
noinst_HEADERS = ppcasm_string.h xine_check.h
--- NEW FILE: xmllexer.c ---
/*
* Copyright (C) 2002-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id: xmllexer.c,v 1.1 2005/04/04 22:38:34 dsalt-guest Exp $
*
*/
#define LOG_MODULE "xmllexer"
#define LOG_VERBOSE
/*
#define LOG
*/
#include "xineutils.h"
#include "xmllexer.h"
#include <stdio.h>
#include <ctype.h>
#include <string.h>
/* private constants*/
#define NORMAL 0 /* normal lex mode */
#define DATA 1 /* data lex mode */
/* private global variables */
static char * lexbuf;
static int lexbuf_size = 0;
static int lexbuf_pos = 0;
static int lex_mode = NORMAL;
static int in_comment = 0;
void lexer_init(char * buf, int size) {
lexbuf = buf;
lexbuf_size = size;
lexbuf_pos = 0;
lex_mode = NORMAL;
in_comment = 0;
lprintf("buffer length %d\n", size);
}
int lexer_get_token(char * tok, int tok_size) {
int tok_pos = 0;
int state = 0;
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);
if (lex_mode == NORMAL) {
/* normal mode */
switch (state) {
/* init state */
case 0:
switch (c) {
case '\n':
case '\r':
state = 1;
tok[tok_pos] = c;
tok_pos++;
break;
case ' ':
case '\t':
state = 2;
tok[tok_pos] = c;
tok_pos++;
break;
case '<':
state = 3;
tok[tok_pos] = c;
tok_pos++;
break;
case '>':
state = 4;
tok[tok_pos] = c;
tok_pos++;
break;
case '/':
if (!in_comment)
state = 5;
tok[tok_pos] = c;
tok_pos++;
break;
case '=':
state = 6;
tok[tok_pos] = c;
tok_pos++;
break;
case '\"': /* " */
state = 7;
break;
case '-':
state = 10;
tok[tok_pos] = c;
tok_pos++;
break;
case '?':
state = 9;
tok[tok_pos] = c;
tok_pos++;
break;
default:
state = 100;
tok[tok_pos] = c;
tok_pos++;
break;
}
lexbuf_pos++;
break;
/* end of line */
case 1:
if (c == '\n' || (c == '\r')) {
tok[tok_pos] = c;
lexbuf_pos++;
tok_pos++;
} else {
tok[tok_pos] = '\0';
return T_EOL;
}
break;
/* T_SEPAR */
case 2:
if (c == ' ' || (c == '\t')) {
tok[tok_pos] = c;
lexbuf_pos++;
tok_pos++;
} else {
tok[tok_pos] = '\0';
return T_SEPAR;
}
break;
/* T_M_START < or </ or <! or <? */
case 3:
switch (c) {
case '/':
tok[tok_pos] = c;
lexbuf_pos++;
tok_pos++; /* FIXME */
tok[tok_pos] = '\0';
return T_M_START_2;
break;
case '!':
tok[tok_pos] = c;
lexbuf_pos++;
tok_pos++;
state = 8;
break;
case '?':
tok[tok_pos] = c;
lexbuf_pos++;
tok_pos++; /* FIXME */
tok[tok_pos] = '\0';
return T_TI_START;
break;
default:
tok[tok_pos] = '\0';
return T_M_START_1;
}
break;
/* T_M_STOP_1 */
case 4:
tok[tok_pos] = '\0';
if (!in_comment)
lex_mode = DATA;
return T_M_STOP_1;
break;
/* T_M_STOP_2 */
case 5:
if (c == '>') {
tok[tok_pos] = c;
lexbuf_pos++;
tok_pos++; /* FIXME */
tok[tok_pos] = '\0';
if (!in_comment)
lex_mode = DATA;
return T_M_STOP_2;
} else {
tok[tok_pos] = '\0';
return T_ERROR;
}
break;
/* T_EQUAL */
case 6:
tok[tok_pos] = '\0';
return T_EQUAL;
break;
/* T_STRING */
case 7:
tok[tok_pos] = c;
lexbuf_pos++;
if (c == '\"') { /* " */
tok[tok_pos] = '\0'; /* FIXME */
return T_STRING;
}
tok_pos++;
break;
/* T_C_START or T_DOCTYPE_START */
case 8:
switch (c) {
case '-':
lexbuf_pos++;
if (lexbuf[lexbuf_pos] == '-')
{
lexbuf_pos++;
tok[tok_pos++] = '-'; /* FIXME */
tok[tok_pos++] = '-';
tok[tok_pos] = '\0';
in_comment = 1;
return T_C_START;
}
break;
case 'D':
lexbuf_pos++;
if (strncmp(lexbuf + lexbuf_pos, "OCTYPE", 6) == 0) {
strncpy(tok + tok_pos, "DOCTYPE", 7); /* FIXME */
lexbuf_pos += 6;
return T_DOCTYPE_START;
} else {
return T_ERROR;
}
break;
default:
/* error */
return T_ERROR;
}
break;
/* T_TI_STOP */
case 9:
if (c == '>') {
tok[tok_pos] = c;
lexbuf_pos++;
tok_pos++; /* FIXME */
tok[tok_pos] = '\0';
return T_TI_STOP;
} else {
tok[tok_pos] = '\0';
return T_ERROR;
}
break;
/* -- */
case 10:
switch (c) {
case '-':
tok[tok_pos] = c;
tok_pos++;
lexbuf_pos++;
state = 11;
break;
default:
tok[tok_pos] = c;
tok_pos++;
lexbuf_pos++;
state = 100;
}
break;
/* --> */
case 11:
switch (c) {
case '>':
tok[tok_pos] = c;
tok_pos++;
lexbuf_pos++;
tok[tok_pos] = '\0'; /* FIX ME */
if (strlen(tok) != 3) {
tok[tok_pos - 3] = '\0';
lexbuf_pos -= 3;
return T_IDENT;
} else {
in_comment = 0;
return T_C_STOP;
}
break;
default:
tok[tok_pos] = c;
tok_pos++;
lexbuf_pos++;
state = 100;
}
break;
/* IDENT */
case 100:
switch (c) {
case '<':
case '>':
case '\\':
case '\"': /* " */
case ' ':
case '\t':
case '=':
case '/':
tok[tok_pos] = '\0';
return T_IDENT;
break;
case '?':
tok[tok_pos] = c;
tok_pos++;
lexbuf_pos++;
state = 9;
break;
case '-':
tok[tok_pos] = c;
tok_pos++;
lexbuf_pos++;
state = 10;
break;
default:
tok[tok_pos] = c;
tok_pos++;
lexbuf_pos++;
}
break;
default:
lprintf("expected char \'%c\'\n", tok[tok_pos - 1]); /* FIX ME */
return T_ERROR;
}
} else {
/* data mode, stop if char equal '<' */
if (c == '<') {
tok[tok_pos] = '\0';
lex_mode = NORMAL;
return T_DATA;
} else {
tok[tok_pos] = c;
tok_pos++;
lexbuf_pos++;
}
}
}
lprintf ("loop done tok_pos = %d, tok_size=%d, lexbuf_pos=%d, lexbuf_size=%d\n",
tok_pos, tok_size, lexbuf_pos, lexbuf_size);
/* pb */
if (tok_pos >= tok_size) {
lprintf("token buffer is too little\n");
} else {
if (lexbuf_pos >= lexbuf_size) {
/* Terminate the current token */
tok[tok_pos] = '\0';
switch (state) {
case 0:
case 1:
case 2:
return T_EOF;
break;
case 3:
return T_M_START_1;
break;
case 4:
return T_M_STOP_1;
break;
case 5:
return T_ERROR;
break;
case 6:
return T_EQUAL;
break;
case 7:
return T_STRING;
break;
case 100:
return T_DATA;
break;
default:
lprintf("unknown state, state=%d\n", state);
}
} else {
lprintf("abnormal end of buffer, state=%d\n", state);
}
}
return T_ERROR;
}
/* tok == null */
lprintf("token buffer is null\n");
return T_ERROR;
}
--- NEW FILE: list.c ---
/*
* Copyright (C) 2000-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id: list.c,v 1.1 2005/04/04 22:38:34 dsalt-guest Exp $
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include "xineutils.h"
/*
* create a new, empty list
*/
xine_list_t *xine_list_new (void) {
xine_list_t *list;
list = (xine_list_t *) xine_xmalloc(sizeof(xine_list_t));
list->first=NULL;
list->last =NULL;
list->cur =NULL;
return list;
}
/*
* dispose a list (and only the list, contents have to be managed separately)
* TODO: this is easy to fix by using "content destructors"
*/
void xine_list_free(xine_list_t *l) {
xine_node_t *node;
if (!l) {
fprintf(stderr, "%s(): No list.\n", __XINE_FUNCTION__);
return;
}
if(!l->first) {
return;
}
node = l->first;
while(node) {
xine_node_t *n = node;
/* TODO: support for content destructors */
node = n->next;
free(n);
}
free(l);
}
void *xine_list_first_content (xine_list_t *l) {
l->cur = l->first;
if (l->first)
return l->first->content;
else
return NULL;
}
void *xine_list_next_content (xine_list_t *l) {
if (l->cur) {
if (l->cur->next) {
l->cur = l->cur->next;
return l->cur->content;
}
else
return NULL;
}
else {
fprintf(stderr,"%s() WARNING: passed end of list\n", __XINE_FUNCTION__);
return NULL;
}
}
int xine_list_is_empty (xine_list_t *l) {
if (l == NULL){
fprintf(stderr, "%s(): list is NULL\n", __XINE_FUNCTION__);
return -1;
}
return (l->first == NULL);
}
void *xine_list_last_content (xine_list_t *l) {
if (l->last) {
l->cur = l->last;
return l->last->content;
}
else {
fprintf(stderr, "xine_list: wanted last of empty list\n");
return NULL;
}
}
void *xine_list_prev_content (xine_list_t *l) {
if (l->cur) {
if (l->cur->prev) {
l->cur = l->cur->prev;
return l->cur->content;
}
else
return NULL;
}
else {
fprintf(stderr, "xine_list: passed begin of list\n");
return NULL;
}
}
void xine_list_append_priority_content (xine_list_t *l, void *content, int priority) {
xine_node_t *node;
node = (xine_node_t *) xine_xmalloc(sizeof(xine_node_t));
node->content = content;
node->priority = priority;
if (l->first) {
xine_node_t *cur;
cur = l->first;
while(1) {
if( priority > cur->priority ) {
node->next = cur;
node->prev = cur->prev;
if( node->prev )
node->prev->next = node;
else
l->first = node;
cur->prev = node;
l->cur = node;
break;
}
if( !cur->next ) {
node->next = NULL;
node->prev = cur;
cur->next = node;
l->cur = node;
l->last = node;
break;
}
cur = cur->next;
}
}
else {
l->first = l->last = l->cur = node;
node->prev = node->next = NULL;
}
}
void xine_list_append_content (xine_list_t *l, void *content) {
xine_node_t *node;
node = (xine_node_t *) xine_xmalloc(sizeof(xine_node_t));
node->content = content;
if (l->last) {
node->next = NULL;
node->prev = l->last;
l->last->next = node;
l->last = node;
l->cur = node;
}
else {
l->first = l->last = l->cur = node;
node->prev = node->next = NULL;
}
}
void xine_list_insert_content (xine_list_t *l, void *content) {
xine_node_t *nodecur, *nodenext, *nodenew;
if(l->cur->next) {
nodenew = (xine_node_t *) xine_xmalloc(sizeof(xine_node_t));
nodenew->content = content;
nodecur = l->cur;
nodenext = l->cur->next;
nodecur->next = nodenew;
nodenext->prev = nodenew;
nodenew->prev = nodecur;
nodenew->next = nodenext;
l->cur = nodenew;
}
else { /* current is last, append to the list */
xine_list_append_content(l, content);
}
}
void xine_list_delete_current (xine_list_t *l) {
xine_node_t *node_cur;
node_cur = l->cur;
if(node_cur->prev) {
node_cur->prev->next = node_cur->next;
}
else { /* First entry */
l->first = node_cur->next;
}
if(node_cur->next) {
node_cur->next->prev = node_cur->prev;
l->cur = node_cur->next;
}
else { /* last entry in the list */
l->last = node_cur->prev;
l->cur = node_cur->prev;
}
/* TODO: support content destructors */
free(node_cur);
}
--- NEW FILE: xmllexer.h ---
/*
* Copyright (C) 2002-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id: xmllexer.h,v 1.1 2005/04/04 22:38:34 dsalt-guest Exp $
*
*/
/* xml lexer */
#ifndef XML_LEXER_H
#define XML_LEXER_H
/* 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(char * buf, int size);
int lexer_get_token(char * tok, int tok_size);
#endif
--- NEW FILE: xmlparser.c ---
/*
* Copyright (C) 2002-2003 the xine project
*
* This file is part of xine, a free video player.
* This file is part of gxine, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* $Id: xmlparser.c,v 1.1 2005/04/04 22:38:34 dsalt-guest Exp $
*
*/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>
#define LOG_MODULE "xmlparser"
#define LOG_VERBOSE
/*
#define LOG
*/
#include "xineutils.h"
#include "xmllexer.h"
#include "xmlparser.h"
#define TOKEN_SIZE 4 * 1024
#define DATA_SIZE 4 * 1024
#define MAX_RECURSION 10
/* private global variables */
static int xml_parser_mode;
/* private functions */
static char * strtoupper(char * str) {
int i = 0;
while (str[i] != '\0') {
str[i] = (char)toupper((int)str[i]);
i++;
}
return str;
}
static xml_node_t * new_xml_node(void) {
xml_node_t * new_node;
new_node = (xml_node_t*) malloc(sizeof(xml_node_t));
new_node->name = NULL;
new_node->data = NULL;
new_node->props = NULL;
new_node->child = NULL;
new_node->next = NULL;
return new_node;
}
static void free_xml_node(xml_node_t * node) {
if (node->name)
free (node->name);
if (node->data)
free (node->data);
free(node);
}
static xml_property_t * new_xml_property(void) {
xml_property_t * new_property;
new_property = (xml_property_t*) malloc(sizeof(xml_property_t));
new_property->name = NULL;
new_property->value = NULL;
new_property->next = NULL;
return new_property;
}
static void free_xml_property(xml_property_t * property) {
if (property->name)
free (property->name);
if (property->value)
free (property->value);
free(property);
}
void xml_parser_init(char * buf, int size, int mode) {
lexer_init(buf, size);
xml_parser_mode = mode;
}
static void xml_parser_free_props(xml_property_t *current_property) {
if (current_property) {
if (!current_property->next) {
free_xml_property(current_property);
} else {
xml_parser_free_props(current_property->next);
free_xml_property(current_property);
}
}
}
static void xml_parser_free_tree_rec(xml_node_t *current_node, int free_next) {
lprintf("xml_parser_free_tree_rec: %s\n", current_node->name);
if (current_node) {
/* properties */
if (current_node->props) {
xml_parser_free_props(current_node->props);
}
/* child nodes */
if (current_node->child) {
lprintf("xml_parser_free_tree_rec: child\n");
xml_parser_free_tree_rec(current_node->child, 1);
}
/* next nodes */
if (free_next) {
xml_node_t *next_node = current_node->next;
xml_node_t *next_next_node;
while (next_node) {
next_next_node = next_node->next;
lprintf("xml_parser_free_tree_rec: next\n");
xml_parser_free_tree_rec(next_node, 0);
next_node = next_next_node;
}
}
free_xml_node(current_node);
}
}
void xml_parser_free_tree(xml_node_t *current_node) {
lprintf("xml_parser_free_tree\n");
xml_parser_free_tree_rec(current_node, 1);
}
#define STATE_IDLE 0
#define STATE_NODE 1
#define STATE_COMMENT 7
static int xml_parser_get_node (xml_node_t *current_node, char *root_name, int rec) {
char tok[TOKEN_SIZE];
char property_name[TOKEN_SIZE];
char node_name[TOKEN_SIZE];
int state = STATE_IDLE;
int res = 0;
int parse_res;
int bypass_get_token = 0;
xml_node_t *subtree = NULL;
xml_node_t *current_subtree = NULL;
xml_property_t *current_property = NULL;
xml_property_t *properties = NULL;
if (rec < MAX_RECURSION) {
while ((bypass_get_token) || (res = lexer_get_token(tok, TOKEN_SIZE)) != T_ERROR) {
bypass_get_token = 0;
lprintf("info: %d - %d : '%s'\n", state, res, tok);
switch (state) {
case STATE_IDLE:
switch (res) {
case (T_EOL):
case (T_SEPAR):
/* do nothing */
break;
case (T_EOF):
return 0; /* normal end */
break;
case (T_M_START_1):
state = STATE_NODE;
break;
case (T_M_START_2):
state = 3;
break;
case (T_C_START):
state = STATE_COMMENT;
break;
case (T_TI_START):
state = 8;
break;
case (T_DOCTYPE_START):
state = 9;
break;
case (T_DATA):
/* current data */
if (current_node->data) {
/* avoid a memory leak */
free(current_node->data);
}
current_node->data = strdup(tok);
lprintf("info: node data : %s\n", current_node->data);
break;
default:
lprintf("error: unexpected token \"%s\", state %d\n", tok, state);
return -1;
break;
}
break;
case STATE_NODE:
switch (res) {
case (T_IDENT):
properties = NULL;
current_property = NULL;
/* save node name */
if (xml_parser_mode == XML_PARSER_CASE_INSENSITIVE) {
strtoupper(tok);
}
strcpy(node_name, tok);
state = 2;
lprintf("info: current node name \"%s\"\n", node_name);
break;
default:
lprintf("error: unexpected token \"%s\", state %d\n", tok, state);
return -1;
break;
}
break;
case 2:
switch (res) {
case (T_EOL):
case (T_SEPAR):
/* nothing */
break;
case (T_M_STOP_1):
/* new subtree */
subtree = new_xml_node();
/* set node name */
subtree->name = strdup(node_name);
/* 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) {
return parse_res;
}
if (current_subtree == NULL) {
current_node->child = subtree;
current_subtree = subtree;
} else {
current_subtree->next = subtree;
current_subtree = subtree;
}
state = STATE_IDLE;
break;
case (T_M_STOP_2):
/* new leaf */
/* new subtree */
subtree = new_xml_node();
/* set node name */
subtree->name = strdup (node_name);
/* set node propertys */
subtree->props = properties;
lprintf("info: rec %d new subtree %s\n", rec, node_name);
if (current_subtree == NULL) {
current_node->child = subtree;
current_subtree = subtree;
} else {
current_subtree->next = subtree;
current_subtree = subtree;
}
state = STATE_IDLE;
break;
case (T_IDENT):
/* save property name */
if (xml_parser_mode == XML_PARSER_CASE_INSENSITIVE) {
strtoupper(tok);
}
strcpy(property_name, tok);
state = 5;
lprintf("info: current property name \"%s\"\n", property_name);
break;
default:
lprintf("error: unexpected token \"%s\", state %d\n", tok, state);
return -1;
break;
}
break;
case 3:
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);
return -1;
}
break;
default:
lprintf("error: unexpected token \"%s\", state %d\n", tok, state);
return -1;
break;
}
break;
/* > expected */
case 4:
switch (res) {
case (T_M_STOP_1):
return 0;
break;
default:
lprintf("error: unexpected token \"%s\", state %d\n", tok, state);
return -1;
break;
}
break;
/* = or > or ident or separator expected */
case 5:
switch (res) {
case (T_EOL):
case (T_SEPAR):
/* do nothing */
break;
case (T_EQUAL):
state = 6;
break;
case (T_IDENT):
bypass_get_token = 1; /* jump to state 2 without get a new token */
state = 2;
break;
case (T_M_STOP_1):
/* 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 = 2;
break;
default:
lprintf("error: unexpected token \"%s\", state %d\n", tok, state);
return -1;
break;
}
break;
/* string or ident or separator expected */
case 6:
switch (res) {
case (T_EOL):
case (T_SEPAR):
/* do nothing */
break;
case (T_STRING):
case (T_IDENT):
/* add a new property */
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);
current_property->value = strdup(tok);
lprintf("info: new property %s=%s\n", current_property->name, current_property->value);
state = 2;
break;
default:
lprintf("error: unexpected token \"%s\", state %d\n", tok, state);
return -1;
break;
}
break;
/* --> expected */
case STATE_COMMENT:
switch (res) {
case (T_C_STOP):
state = STATE_IDLE;
break;
default:
state = STATE_COMMENT;
break;
}
break;
/* > expected */
case 8:
switch (res) {
case (T_TI_STOP):
state = 0;
break;
default:
state = 8;
break;
}
break;
/* ?> expected */
case 9:
switch (res) {
case (T_M_STOP_1):
state = 0;
break;
default:
state = 9;
break;
}
break;
default:
lprintf("error: unknown parser state, state=%d\n", state);
return -1;
}
}
/* lex error */
lprintf("error: lexer error\n");
return -1;
} else {
/* max recursion */
lprintf("error: max recursion\n");
return -1;
}
}
int xml_parser_build_tree(xml_node_t **root_node) {
xml_node_t *tmp_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;
free_xml_node(tmp_node);
res = 0;
} else {
lprintf("error: xml struct\n");
xml_parser_free_tree(tmp_node);
res = -1;
}
return res;
}
char *xml_parser_get_property (xml_node_t *node, const char *name) {
xml_property_t *prop;
prop = node->props;
while (prop) {
lprintf ("looking for %s in %s\n", name, prop->name);
if (!strcasecmp (prop->name, name)) {
lprintf ("found it. value=%s\n", prop->value);
return prop->value;
}
prop = prop->next;
}
return NULL;
}
int xml_parser_get_property_int (xml_node_t *node, const char *name,
int def_value) {
char *v;
int ret;
v = xml_parser_get_property (node, name);
if (!v)
return def_value;
if (sscanf (v, "%d", &ret) != 1)
return def_value;
else
return ret;
}
int xml_parser_get_property_bool (xml_node_t *node, const char *name,
int def_value) {
char *v;
v = xml_parser_get_property (node, name);
if (!v)
return def_value;
if (!strcasecmp (v, "true"))
return 1;
else
return 0;
}
static void printf_indent (int indent, const char *format, ...) {
int i ;
va_list argp;
for (i=0; i<indent; i++)
printf (" ");
va_start (argp, format);
vprintf (format, argp);
va_end (argp);
}
static void xml_parser_dump_node (xml_node_t *node, int indent) {
xml_property_t *p;
xml_node_t *n;
int l;
printf_indent (indent, "<%s ", node->name);
l = strlen (node->name);
p = node->props;
while (p) {
printf ("%s='%s'", p->name, p->value);
p = p->next;
if (p) {
printf ("\n");
printf_indent (indent+2+l, "");
}
}
printf (">\n");
n = node->child;
while (n) {
xml_parser_dump_node (n, indent+2);
n = n->next;
}
printf_indent (indent, "</%s>\n", node->name);
}
void xml_parser_dump_tree (xml_node_t *node) {
xml_parser_dump_node (node, 0);
}
--- NEW FILE: memcpy.c ---
/*
* Copyright (C) 2001-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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* These are the MMX/MMX2/SSE optimized versions of memcpy
*
* This code was adapted from Linux Kernel sources by Nick Kurshev to
* the mplayer program. (http://mplayer.sourceforge.net)
*
* Miguel Freitas split the #ifdefs into several specialized functions that
* are benchmarked at runtime by xine. Some original comments from Nick
* have been preserved documenting some MMX/SSE oddities.
* Also added kernel memcpy function that seems faster than libc one.
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if defined (ARCH_PPC) && !defined (HOST_OS_DARWIN)
#include "ppcasm_string.h"
#endif
#ifdef HAVE_SYS_TIMES_H
#include <sys/times.h>
#endif
#include <stdlib.h>
#include <string.h>
#define LOG_MODULE "memcpy"
#define LOG_VERBOSE
/*
#define LOG
*/
#include "xine_internal.h"
void *(* xine_fast_memcpy)(void *to, const void *from, size_t len);
/* Original comments from mplayer (file: aclib.c)
This part of code was taken by me from Linux-2.4.3 and slightly modified
for MMX, MMX2, SSE instruction set. I have done it since linux uses page aligned
blocks but mplayer uses weakly ordered data and original sources can not
speedup them. Only using PREFETCHNTA and MOVNTQ together have effect!
>From IA-32 Intel Architecture Software Developer's Manual Volume 1,
Order Number 245470:
"10.4.6. Cacheability Control, Prefetch, and Memory Ordering Instructions"
Data referenced by a program can be temporal (data will be used again) or
non-temporal (data will be referenced once and not reused in the immediate
future). To make efficient use of the processor's caches, it is generally
desirable to cache temporal data and not cache non-temporal data. Overloading
the processor's caches with non-temporal data is sometimes referred to as
"polluting the caches".
The non-temporal data is written to memory with Write-Combining semantics.
The PREFETCHh instructions permits a program to load data into the processor
at a suggested cache level, so that it is closer to the processors load and
store unit when it is needed. If the data is already present in a level of
the cache hierarchy that is closer to the processor, the PREFETCHh instruction
will not result in any data movement.
But we should you PREFETCHNTA: Non-temporal data fetch data into location
close to the processor, minimizing cache pollution.
The MOVNTQ (store quadword using non-temporal hint) instruction stores
packed integer data from an MMX register to memory, using a non-temporal hint.
The MOVNTPS (store packed single-precision floating-point values using
non-temporal hint) instruction stores packed floating-point data from an
XMM register to memory, using a non-temporal hint.
The SFENCE (Store Fence) instruction controls write ordering by creating a
fence for memory store operations. This instruction guarantees that the results
of every store instruction that precedes the store fence in program order is
globally visible before any store instruction that follows the fence. The
SFENCE instruction provides an efficient way of ensuring ordering between
procedures that produce weakly-ordered data and procedures that consume that
data.
If you have questions please contact with me: Nick Kurshev: nickols_k@mail.ru.
*/
/* mmx v.1 Note: Since we added alignment of destinition it speedups
of memory copying on PentMMX, Celeron-1 and P2 upto 12% versus
standard (non MMX-optimized) version.
Note: on K6-2+ it speedups memory copying upto 25% and
on K7 and P3 about 500% (5 times).
*/
/* Additional notes on gcc assembly and processors: [MF]
prefetch is specific for AMD processors, the intel ones should be
prefetch0, prefetch1, prefetch2 which are not recognized by my gcc.
prefetchnta is supported both on athlon and pentium 3.
therefore i will take off prefetchnta instructions from the mmx1 version
to avoid problems on pentium mmx and k6-2.
quote of the day:
"Using prefetches efficiently is more of an art than a science"
*/
#if defined(ARCH_X86) || defined(ARCH_X86_64)
#ifndef _MSC_VER
/* for small memory blocks (<256 bytes) this version is faster */
#define small_memcpy(to,from,n)\
{\
register unsigned long int dummy;\
__asm__ __volatile__(\
"rep; movsb"\
:"=&D"(to), "=&S"(from), "=&c"(dummy)\
:"0" (to), "1" (from),"2" (n)\
: "memory");\
}
/* linux kernel __memcpy (from: /include/asm/string.h) */
static __inline__ void * linux_kernel_memcpy_impl (
void * to,
const void * from,
size_t n)
{
int d0, d1, d2;
if( n < 4 ) {
small_memcpy(to,from,n);
}
else
__asm__ __volatile__(
"rep ; movsl\n\t"
"testb $2,%b4\n\t"
"je 1f\n\t"
"movsw\n"
"1:\ttestb $1,%b4\n\t"
"je 2f\n\t"
"movsb\n"
"2:"
: "=&c" (d0), "=&D" (d1), "=&S" (d2)
:"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from)
: "memory");
return (to);
}
#define SSE_MMREG_SIZE 16
#define MMX_MMREG_SIZE 8
#define MMX1_MIN_LEN 0x800 /* 2K blocks */
#define MIN_LEN 0x40 /* 64-byte blocks */
/* SSE note: i tried to move 128 bytes a time instead of 64 but it
didn't make any measureable difference. i'm using 64 for the sake of
simplicity. [MF] */
static void * sse_memcpy(void * to, const void * from, size_t len)
{
void *retval;
size_t i;
retval = to;
/* PREFETCH has effect even for MOVSB instruction ;) */
__asm__ __volatile__ (
" prefetchnta (%0)\n"
" prefetchnta 32(%0)\n"
" prefetchnta 64(%0)\n"
" prefetchnta 96(%0)\n"
" prefetchnta 128(%0)\n"
" prefetchnta 160(%0)\n"
" prefetchnta 192(%0)\n"
" prefetchnta 224(%0)\n"
" prefetchnta 256(%0)\n"
" prefetchnta 288(%0)\n"
: : "r" (from) );
if(len >= MIN_LEN)
{
register unsigned long int delta;
/* Align destinition to MMREG_SIZE -boundary */
delta = ((unsigned long int)to)&(SSE_MMREG_SIZE-1);
if(delta)
{
delta=SSE_MMREG_SIZE-delta;
len -= delta;
small_memcpy(to, from, delta);
}
i = len >> 6; /* len/64 */
len&=63;
if(((unsigned long)from) & 15)
/* if SRC is misaligned */
for(; i>0; i--)
{
__asm__ __volatile__ (
"prefetchnta 320(%0)\n"
"prefetchnta 352(%0)\n"
"movups (%0), %%xmm0\n"
"movups 16(%0), %%xmm1\n"
"movups 32(%0), %%xmm2\n"
"movups 48(%0), %%xmm3\n"
"movntps %%xmm0, (%1)\n"
"movntps %%xmm1, 16(%1)\n"
"movntps %%xmm2, 32(%1)\n"
"movntps %%xmm3, 48(%1)\n"
:: "r" (from), "r" (to) : "memory");
((const unsigned char *)from)+=64;
((unsigned char *)to)+=64;
}
else
/*
Only if SRC is aligned on 16-byte boundary.
It allows to use movaps instead of movups, which required data
to be aligned or a general-protection exception (#GP) is generated.
*/
for(; i>0; i--)
{
__asm__ __volatile__ (
"prefetchnta 320(%0)\n"
"prefetchnta 352(%0)\n"
"movaps (%0), %%xmm0\n"
"movaps 16(%0), %%xmm1\n"
"movaps 32(%0), %%xmm2\n"
"movaps 48(%0), %%xmm3\n"
"movntps %%xmm0, (%1)\n"
"movntps %%xmm1, 16(%1)\n"
"movntps %%xmm2, 32(%1)\n"
"movntps %%xmm3, 48(%1)\n"
:: "r" (from), "r" (to) : "memory");
((const unsigned char *)from)+=64;
((unsigned char *)to)+=64;
}
/* since movntq is weakly-ordered, a "sfence"
* is needed to become ordered again. */
__asm__ __volatile__ ("sfence":::"memory");
/* enables to use FPU */
__asm__ __volatile__ ("emms":::"memory");
}
/*
* Now do the tail of the block
*/
if(len) linux_kernel_memcpy_impl(to, from, len);
return retval;
}
static void * mmx_memcpy(void * to, const void * from, size_t len)
{
void *retval;
size_t i;
retval = to;
if(len >= MMX1_MIN_LEN)
{
register unsigned long int delta;
/* Align destinition to MMREG_SIZE -boundary */
delta = ((unsigned long int)to)&(MMX_MMREG_SIZE-1);
if(delta)
{
delta=MMX_MMREG_SIZE-delta;
len -= delta;
small_memcpy(to, from, delta);
}
i = len >> 6; /* len/64 */
len&=63;
for(; i>0; i--)
{
__asm__ __volatile__ (
"movq (%0), %%mm0\n"
"movq 8(%0), %%mm1\n"
"movq 16(%0), %%mm2\n"
"movq 24(%0), %%mm3\n"
"movq 32(%0), %%mm4\n"
"movq 40(%0), %%mm5\n"
"movq 48(%0), %%mm6\n"
"movq 56(%0), %%mm7\n"
"movq %%mm0, (%1)\n"
"movq %%mm1, 8(%1)\n"
"movq %%mm2, 16(%1)\n"
"movq %%mm3, 24(%1)\n"
"movq %%mm4, 32(%1)\n"
"movq %%mm5, 40(%1)\n"
"movq %%mm6, 48(%1)\n"
"movq %%mm7, 56(%1)\n"
:: "r" (from), "r" (to) : "memory");
((const unsigned char *)from)+=64;
((unsigned char *)to)+=64;
}
__asm__ __volatile__ ("emms":::"memory");
}
/*
* Now do the tail of the block
*/
if(len) linux_kernel_memcpy_impl(to, from, len);
return retval;
}
static void * mmx2_memcpy(void * to, const void * from, size_t len)
{
void *retval;
size_t i;
retval = to;
/* PREFETCH has effect even for MOVSB instruction ;) */
__asm__ __volatile__ (
" prefetchnta (%0)\n"
" prefetchnta 32(%0)\n"
" prefetchnta 64(%0)\n"
" prefetchnta 96(%0)\n"
" prefetchnta 128(%0)\n"
" prefetchnta 160(%0)\n"
" prefetchnta 192(%0)\n"
" prefetchnta 224(%0)\n"
" prefetchnta 256(%0)\n"
" prefetchnta 288(%0)\n"
: : "r" (from) );
if(len >= MIN_LEN)
{
register unsigned long int delta;
/* Align destinition to MMREG_SIZE -boundary */
delta = ((unsigned long int)to)&(MMX_MMREG_SIZE-1);
if(delta)
{
delta=MMX_MMREG_SIZE-delta;
len -= delta;
small_memcpy(to, from, delta);
}
i = len >> 6; /* len/64 */
len&=63;
for(; i>0; i--)
{
__asm__ __volatile__ (
"prefetchnta 320(%0)\n"
"prefetchnta 352(%0)\n"
"movq (%0), %%mm0\n"
"movq 8(%0), %%mm1\n"
"movq 16(%0), %%mm2\n"
"movq 24(%0), %%mm3\n"
"movq 32(%0), %%mm4\n"
"movq 40(%0), %%mm5\n"
"movq 48(%0), %%mm6\n"
"movq 56(%0), %%mm7\n"
"movntq %%mm0, (%1)\n"
"movntq %%mm1, 8(%1)\n"
"movntq %%mm2, 16(%1)\n"
"movntq %%mm3, 24(%1)\n"
"movntq %%mm4, 32(%1)\n"
"movntq %%mm5, 40(%1)\n"
"movntq %%mm6, 48(%1)\n"
"movntq %%mm7, 56(%1)\n"
:: "r" (from), "r" (to) : "memory");
((const unsigned char *)from)+=64;
((unsigned char *)to)+=64;
}
/* since movntq is weakly-ordered, a "sfence"
* is needed to become ordered again. */
__asm__ __volatile__ ("sfence":::"memory");
__asm__ __volatile__ ("emms":::"memory");
}
/*
* Now do the tail of the block
*/
if(len) linux_kernel_memcpy_impl(to, from, len);
return retval;
}
static void *linux_kernel_memcpy(void *to, const void *from, size_t len) {
return linux_kernel_memcpy_impl(to,from,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! */
uint32_t cpu_require;
} memcpy_method[] =
{
{ NULL, NULL, 0, 0 },
{ "libc memcpy()", memcpy, 0, 0 },
#if defined(ARCH_X86) && !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 },
#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 },
#endif /* ARCH_PPC && !HOST_OS_DARWIN */
{ NULL, NULL, 0, 0 }
};
#if defined(ARCH_X86) && defined(HAVE_SYS_TIMES_H)
static unsigned long long int rdtsc(int config_flags)
{
unsigned long long int x;
/* that should prevent us from trying cpuid with old cpus */
if( config_flags & MM_MMX ) {
__asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
return x;
} else {
return times(NULL);
}
}
#else
static uint64_t rdtsc(int config_flags)
{
/* FIXME: implement an equivalent for using optimized memcpy on other
architectures */
#ifdef HAVE_SYS_TIMES_H
struct tms tp;
return times(&tp);
#else
return ((uint64_t)0);
#endif /* HAVE_SYS_TIMES_H */
}
#endif
static void update_fast_memcpy(void *user_data, xine_cfg_entry_t *entry) {
static int config_flags = -1;
xine_t *xine = (xine_t *) user_data;
int method;
config_flags = xine_mm_accel();
method = entry->num_value;
if (method != 0
&& (config_flags & memcpy_method[method].cpu_require) ==
memcpy_method[method].cpu_require ) {
lprintf("using %s\n", memcpy_method[method].name );
xine_fast_memcpy = memcpy_method[method].function;
return;
} else {
xprintf(xine, XINE_VERBOSITY_DEBUG, "xine: will probe memcpy on startup\n" );
}
}
#define BUFSIZE 1024*1024
void xine_probe_fast_memcpy(xine_t *xine)
{
uint64_t t;
char *buf1, *buf2;
int i, j, best;
int config_flags = -1;
static char *memcpy_methods[] = {
"probe", "libc",
#if defined(ARCH_X86) && !defined(_MSC_VER)
"kernel", "mmx", "mmxext", "sse",
#endif
#if defined (ARCH_PPC) && !defined (HOST_OS_DARWIN)
"ppcasm_memcpy", "ppcasm_cacheable_memcpy",
#endif
NULL
};
config_flags = xine_mm_accel();
best = xine->config->register_enum (xine->config, "engine.performance.memcpy_method", 0,
memcpy_methods,
_("memcopy method used by xine"),
_("The copying of large memory blocks is one of the most "
"expensive operations on todays computers. Therefore xine "
"provides various tuned methods to do this copying. "
"Usually, the best method is detected automatically."),
20, update_fast_memcpy, (void *) xine);
/* check if function is configured and valid for this machine */
if( best != 0 &&
(config_flags & memcpy_method[best].cpu_require) ==
memcpy_method[best].cpu_require ) {
lprintf("using %s\n", memcpy_method[best].name );
xine_fast_memcpy = memcpy_method[best].function;
return;
}
best = 0;
xine_fast_memcpy = memcpy;
if( (buf1 = malloc(BUFSIZE)) == NULL )
return;
if( (buf2 = malloc(BUFSIZE)) == NULL ) {
free(buf1);
return;
}
xprintf(xine, XINE_VERBOSITY_LOG, _("Benchmarking memcpy methods (smaller is better):\n"));
/* make sure buffers are present on physical memory */
memset(buf1,0,BUFSIZE);
memset(buf2,0,BUFSIZE);
for(i=1; memcpy_method[i].name; i++)
{
if( (config_flags & memcpy_method[i].cpu_require) !=
memcpy_method[i].cpu_require )
continue;
t = rdtsc(config_flags);
for(j=0;j<50;j++) {
memcpy_method[i].function(buf2,buf1,BUFSIZE);
memcpy_method[i].function(buf1,buf2,BUFSIZE);
}
t = rdtsc(config_flags) - t;
memcpy_method[i].time = t;
xprintf(xine, XINE_VERBOSITY_LOG, "\t%s : %lld\n", memcpy_method[i].name, t);
if( best == 0 || t < memcpy_method[best].time )
best = i;
}
xine->config->update_num (xine->config, "engine.performance.memcpy_method", best);
free(buf1);
free(buf2);
}
--- NEW FILE: ppcasm_string.h ---
#include <stdlib.h>
void *ppcasm_cacheable_memcpy(void *, const void *, size_t);
void *ppcasm_memcpy(void *, const void *, size_t);
--- NEW FILE: Makefile.in ---
# Makefile.in generated by automake 1.9.3 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
SOURCES = $(libxineutils_la_SOURCES)
srcdir = @srcdir@
top_srcdir = @top_srcdir@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
top_builddir = ../..
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
INSTALL = @INSTALL@
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
DIST_COMMON = $(include_HEADERS) $(noinst_HEADERS) \
$(srcdir)/Makefile.am $(srcdir)/Makefile.in \
$(top_srcdir)/misc/Makefile.common
subdir = src/xine-utils
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/_xine.m4 $(top_srcdir)/m4/aa.m4 \
$(top_srcdir)/m4/alsa.m4 $(top_srcdir)/m4/arts.m4 \
$(top_srcdir)/m4/as.m4 $(top_srcdir)/m4/caca.m4 \
$(top_srcdir)/m4/codeset.m4 $(top_srcdir)/m4/directx.m4 \
$(top_srcdir)/m4/dl.m4 $(top_srcdir)/m4/dvdnav.m4 \
$(top_srcdir)/m4/esd.m4 $(top_srcdir)/m4/ffmpeg.m4 \
$(top_srcdir)/m4/freetype2.m4 $(top_srcdir)/m4/gettext.m4 \
$(top_srcdir)/m4/glibc21.m4 $(top_srcdir)/m4/iconv.m4 \
$(top_srcdir)/m4/irixal.m4 $(top_srcdir)/m4/lcmessage.m4 \
$(top_srcdir)/m4/libFLAC.m4 $(top_srcdir)/m4/libfame.m4 \
$(top_srcdir)/m4/ogg.m4 $(top_srcdir)/m4/opengl.m4 \
$(top_srcdir)/m4/pkg.m4 $(top_srcdir)/m4/progtest.m4 \
$(top_srcdir)/m4/sdl.m4 $(top_srcdir)/m4/speex.m4 \
$(top_srcdir)/m4/theora.m4 $(top_srcdir)/m4/vorbis.m4 \
$(top_srcdir)/m4/xv.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
LTLIBRARIES = $(noinst_LTLIBRARIES)
libxineutils_la_LIBADD =
am__libxineutils_la_SOURCES_DIST = ppcasm_string.S cpu_accel.c color.c \
copy.c list.c memcpy.c monitor.c utils.c xine_check.c \
xine_mutex.c xmllexer.c xine_buffer.c xmlparser.c
@HOST_OS_DARWIN_FALSE@@PPC_ARCH_TRUE@am__objects_1 = ppcasm_string.lo
am_libxineutils_la_OBJECTS = $(am__objects_1) cpu_accel.lo color.lo \
copy.lo list.lo memcpy.lo monitor.lo utils.lo xine_check.lo \
xine_mutex.lo xmllexer.lo xine_buffer.lo xmlparser.lo
libxineutils_la_OBJECTS = $(am_libxineutils_la_OBJECTS)
DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/depcomp
am__depfiles_maybe = depfiles
LTCCASCOMPILE = $(LIBTOOL) --mode=compile $(CCAS) $(AM_CCASFLAGS) \
$(CCASFLAGS)
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) \
$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
$(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --tag=CC --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
$(AM_LDFLAGS) $(LDFLAGS) -o $@
SOURCES = $(libxineutils_la_SOURCES)
DIST_SOURCES = $(am__libxineutils_la_SOURCES_DIST)
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
am__installdirs = "$(DESTDIR)$(includedir)"
includeHEADERS_INSTALL = $(INSTALL_HEADER)
HEADERS = $(include_HEADERS) $(noinst_HEADERS)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
AAINFO = @AAINFO@
AALIB_CFLAGS = @AALIB_CFLAGS@
AALIB_CONFIG = @AALIB_CONFIG@
AALIB_LIBS = @AALIB_LIBS@
ACLOCAL = @ACLOCAL@
ACLOCAL_DIR = @ACLOCAL_DIR@
ALLOCA = @ALLOCA@
ALSA_CFLAGS = @ALSA_CFLAGS@
ALSA_LIBS = @ALSA_LIBS@
ALSA_STATIC_LIB = @ALSA_STATIC_LIB@
AMDEP_FALSE = @AMDEP_FALSE@
AMDEP_TRUE = @AMDEP_TRUE@
AMTAR = @AMTAR@
AR = @AR@
ARTS_CFLAGS = @ARTS_CFLAGS@
ARTS_CONFIG = @ARTS_CONFIG@
ARTS_LIBS = @ARTS_LIBS@
AS = @AS@
ASFLAGS = @ASFLAGS@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
BUILD_ASF_FALSE = @BUILD_ASF_FALSE@
BUILD_ASF_TRUE = @BUILD_ASF_TRUE@
BUILD_DHA_KMOD_FALSE = @BUILD_DHA_KMOD_FALSE@
BUILD_DHA_KMOD_TRUE = @BUILD_DHA_KMOD_TRUE@
BUILD_FAAD_FALSE = @BUILD_FAAD_FALSE@
BUILD_FAAD_TRUE = @BUILD_FAAD_TRUE@
BUILD_INCLUDED_LIBINTL = @BUILD_INCLUDED_LIBINTL@
CACA_CFLAGS = @CACA_CFLAGS@
CACA_CONFIG = @CACA_CONFIG@
CACA_LIBS = @CACA_LIBS@
CATALOGS = @CATALOGS@
CATOBJEXT = @CATOBJEXT@
CC = @CC@
CCAS = @CCAS@
CCASCOMPILE = @CCASCOMPILE@
CCASFLAGS = @CCASFLAGS@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CXX = @CXX@
CXXCPP = @CXXCPP@
CXXDEPMODE = @CXXDEPMODE@
CXXFLAGS = @CXXFLAGS@
CYGPATH_W = @CYGPATH_W@
DATADIRNAME = @DATADIRNAME@
DEBUG_CFLAGS = @DEBUG_CFLAGS@
DEFS = @DEFS@
DEPCOMP = @DEPCOMP@
DEPDIR = @DEPDIR@
DEPMOD = @DEPMOD@
DIRECTFB_CFLAGS = @DIRECTFB_CFLAGS@
DIRECTFB_LIBS = @DIRECTFB_LIBS@
DIRECTX_AUDIO_LIBS = @DIRECTX_AUDIO_LIBS@
DIRECTX_CPPFLAGS = @DIRECTX_CPPFLAGS@
DIRECTX_VIDEO_LIBS = @DIRECTX_VIDEO_LIBS@
DLLTOOL = @DLLTOOL@
DVDNAV_CFLAGS = @DVDNAV_CFLAGS@
DVDNAV_CONFIG = @DVDNAV_CONFIG@
DVDNAV_LIBS = @DVDNAV_LIBS@
DYNAMIC_LD_LIBS = @DYNAMIC_LD_LIBS@
ECHO = @ECHO@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
ENABLE_VCD_FALSE = @ENABLE_VCD_FALSE@
ENABLE_VCD_TRUE = @ENABLE_VCD_TRUE@
ESD_CFLAGS = @ESD_CFLAGS@
ESD_CONFIG = @ESD_CONFIG@
ESD_LIBS = @ESD_LIBS@
EXEEXT = @EXEEXT@
EXTRA_X_CFLAGS = @EXTRA_X_CFLAGS@
EXTRA_X_LIBS = @EXTRA_X_LIBS@
F77 = @F77@
FFLAGS = @FFLAGS@
FFMPEG_CPPFLAGS = @FFMPEG_CPPFLAGS@
FFMPEG_LIBS = @FFMPEG_LIBS@
FIG2DEV = @FIG2DEV@
FREETYPE_CONFIG = @FREETYPE_CONFIG@
FT2_CFLAGS = @FT2_CFLAGS@
FT2_LIBS = @FT2_LIBS@
GENCAT = @GENCAT@
GLIBC21 = @GLIBC21@
GLUT_LIBS = @GLUT_LIBS@
GLU_LIBS = @GLU_LIBS@
GMOFILES = @GMOFILES@
GMSGFMT = @GMSGFMT@
GNOME_VFS_CFLAGS = @GNOME_VFS_CFLAGS@
GNOME_VFS_LIBS = @GNOME_VFS_LIBS@
GOOM_LIBS = @GOOM_LIBS@
HAVE_AA_FALSE = @HAVE_AA_FALSE@
HAVE_AA_TRUE = @HAVE_AA_TRUE@
HAVE_ALSA09_FALSE = @HAVE_ALSA09_FALSE@
HAVE_ALSA09_TRUE = @HAVE_ALSA09_TRUE@
HAVE_ALSA_FALSE = @HAVE_ALSA_FALSE@
HAVE_ALSA_TRUE = @HAVE_ALSA_TRUE@
HAVE_ARMV4L_FALSE = @HAVE_ARMV4L_FALSE@
HAVE_ARMV4L_TRUE = @HAVE_ARMV4L_TRUE@
HAVE_ARTS_FALSE = @HAVE_ARTS_FALSE@
HAVE_ARTS_TRUE = @HAVE_ARTS_TRUE@
HAVE_BSDI_CDROM = @HAVE_BSDI_CDROM@
HAVE_CACA_FALSE = @HAVE_CACA_FALSE@
HAVE_CACA_TRUE = @HAVE_CACA_TRUE@
HAVE_CDROM_IOCTLS_FALSE = @HAVE_CDROM_IOCTLS_FALSE@
HAVE_CDROM_IOCTLS_TRUE = @HAVE_CDROM_IOCTLS_TRUE@
HAVE_COREAUDIO_FALSE = @HAVE_COREAUDIO_FALSE@
HAVE_COREAUDIO_TRUE = @HAVE_COREAUDIO_TRUE@
HAVE_DARWIN_CDROM = @HAVE_DARWIN_CDROM@
HAVE_DIRECTFB_FALSE = @HAVE_DIRECTFB_FALSE@
HAVE_DIRECTFB_TRUE = @HAVE_DIRECTFB_TRUE@
HAVE_DIRECTX_FALSE = @HAVE_DIRECTX_FALSE@
HAVE_DIRECTX_TRUE = @HAVE_DIRECTX_TRUE@
HAVE_DVDNAV_FALSE = @HAVE_DVDNAV_FALSE@
HAVE_DVDNAV_TRUE = @HAVE_DVDNAV_TRUE@
HAVE_DXR3_FALSE = @HAVE_DXR3_FALSE@
HAVE_DXR3_TRUE = @HAVE_DXR3_TRUE@
HAVE_ESD_FALSE = @HAVE_ESD_FALSE@
HAVE_ESD_TRUE = @HAVE_ESD_TRUE@
HAVE_FB_FALSE = @HAVE_FB_FALSE@
HAVE_FB_TRUE = @HAVE_FB_TRUE@
HAVE_FFMMX_FALSE = @HAVE_FFMMX_FALSE@
HAVE_FFMMX_TRUE = @HAVE_FFMMX_TRUE@
HAVE_FFMPEG_FALSE = @HAVE_FFMPEG_FALSE@
HAVE_FFMPEG_TRUE = @HAVE_FFMPEG_TRUE@
HAVE_FIG2DEV_FALSE = @HAVE_FIG2DEV_FALSE@
HAVE_FIG2DEV_TRUE = @HAVE_FIG2DEV_TRUE@
HAVE_FLAC_FALSE = @HAVE_FLAC_FALSE@
HAVE_FLAC_TRUE = @HAVE_FLAC_TRUE@
HAVE_FREEBSD_CDROM = @HAVE_FREEBSD_CDROM@
HAVE_GNOME_VFS_FALSE = @HAVE_GNOME_VFS_FALSE@
HAVE_GNOME_VFS_TRUE = @HAVE_GNOME_VFS_TRUE@
HAVE_IRIXAL_FALSE = @HAVE_IRIXAL_FALSE@
HAVE_IRIXAL_TRUE = @HAVE_IRIXAL_TRUE@
HAVE_LIBFAME_FALSE = @HAVE_LIBFAME_FALSE@
HAVE_LIBFAME_TRUE = @HAVE_LIBFAME_TRUE@
HAVE_LIBMNG_FALSE = @HAVE_LIBMNG_FALSE@
HAVE_LIBMNG_TRUE = @HAVE_LIBMNG_TRUE@
HAVE_LIBPNG_FALSE = @HAVE_LIBPNG_FALSE@
HAVE_LIBPNG_TRUE = @HAVE_LIBPNG_TRUE@
HAVE_LIBRTE_FALSE = @HAVE_LIBRTE_FALSE@
HAVE_LIBRTE_TRUE = @HAVE_LIBRTE_TRUE@
HAVE_LIBSMBCLIENT_FALSE = @HAVE_LIBSMBCLIENT_FALSE@
HAVE_LIBSMBCLIENT_TRUE = @HAVE_LIBSMBCLIENT_TRUE@
HAVE_LINUX_CDROM = @HAVE_LINUX_CDROM@
HAVE_LINUX_FALSE = @HAVE_LINUX_FALSE@
HAVE_LINUX_TRUE = @HAVE_LINUX_TRUE@
HAVE_MACOSX_VIDEO_FALSE = @HAVE_MACOSX_VIDEO_FALSE@
HAVE_MACOSX_VIDEO_TRUE = @HAVE_MACOSX_VIDEO_TRUE@
HAVE_MLIB_FALSE = @HAVE_MLIB_FALSE@
HAVE_MLIB_TRUE = @HAVE_MLIB_TRUE@
HAVE_OPENGL_FALSE = @HAVE_OPENGL_FALSE@
HAVE_OPENGL_TRUE = @HAVE_OPENGL_TRUE@
HAVE_OSS_FALSE = @HAVE_OSS_FALSE@
HAVE_OSS_TRUE = @HAVE_OSS_TRUE@
HAVE_POLYPAUDIO_FALSE = @HAVE_POLYPAUDIO_FALSE@
HAVE_POLYPAUDIO_TRUE = @HAVE_POLYPAUDIO_TRUE@
HAVE_SDL_FALSE = @HAVE_SDL_FALSE@
HAVE_SDL_TRUE = @HAVE_SDL_TRUE@
HAVE_SGMLTOOLS_FALSE = @HAVE_SGMLTOOLS_FALSE@
HAVE_SGMLTOOLS_TRUE = @HAVE_SGMLTOOLS_TRUE@
HAVE_SOLARIS_CDROM = @HAVE_SOLARIS_CDROM@
HAVE_SPEEX_FALSE = @HAVE_SPEEX_FALSE@
HAVE_SPEEX_TRUE = @HAVE_SPEEX_TRUE@
HAVE_STK_FALSE = @HAVE_STK_FALSE@
HAVE_STK_TRUE = @HAVE_STK_TRUE@
HAVE_SUNAUDIO_FALSE = @HAVE_SUNAUDIO_FALSE@
HAVE_SUNAUDIO_TRUE = @HAVE_SUNAUDIO_TRUE@
HAVE_SUNDGA_FALSE = @HAVE_SUNDGA_FALSE@
HAVE_SUNDGA_TRUE = @HAVE_SUNDGA_TRUE@
HAVE_SUNFB_FALSE = @HAVE_SUNFB_FALSE@
HAVE_SUNFB_TRUE = @HAVE_SUNFB_TRUE@
HAVE_SYNCFB_FALSE = @HAVE_SYNCFB_FALSE@
HAVE_SYNCFB_TRUE = @HAVE_SYNCFB_TRUE@
HAVE_THEORA_FALSE = @HAVE_THEORA_FALSE@
HAVE_THEORA_TRUE = @HAVE_THEORA_TRUE@
HAVE_V4L_FALSE = @HAVE_V4L_FALSE@
HAVE_V4L_TRUE = @HAVE_V4L_TRUE@
HAVE_VCDNAV_FALSE = @HAVE_VCDNAV_FALSE@
HAVE_VCDNAV_TRUE = @HAVE_VCDNAV_TRUE@
HAVE_VIDIX_FALSE = @HAVE_VIDIX_FALSE@
HAVE_VIDIX_TRUE = @HAVE_VIDIX_TRUE@
HAVE_VLDXVMC_FALSE = @HAVE_VLDXVMC_FALSE@
HAVE_VLDXVMC_TRUE = @HAVE_VLDXVMC_TRUE@
HAVE_VORBIS_FALSE = @HAVE_VORBIS_FALSE@
HAVE_VORBIS_TRUE = @HAVE_VORBIS_TRUE@
HAVE_W32DLL_FALSE = @HAVE_W32DLL_FALSE@
HAVE_W32DLL_TRUE = @HAVE_W32DLL_TRUE@
HAVE_WIN32_CDROM = @HAVE_WIN32_CDROM@
HAVE_X11_FALSE = @HAVE_X11_FALSE@
HAVE_X11_TRUE = @HAVE_X11_TRUE@
HAVE_XVMC_FALSE = @HAVE_XVMC_FALSE@
HAVE_XVMC_TRUE = @HAVE_XVMC_TRUE@
HAVE_XV_FALSE = @HAVE_XV_FALSE@
HAVE_XV_TRUE = @HAVE_XV_TRUE@
HAVE_XXMC_FALSE = @HAVE_XXMC_FALSE@
HAVE_XXMC_TRUE = @HAVE_XXMC_TRUE@
HAVE_ZLIB_FALSE = @HAVE_ZLIB_FALSE@
HAVE_ZLIB_TRUE = @HAVE_ZLIB_TRUE@
HOST_OS_DARWIN_FALSE = @HOST_OS_DARWIN_FALSE@
HOST_OS_DARWIN_TRUE = @HOST_OS_DARWIN_TRUE@
INCLUDED_INTL_FALSE = @INCLUDED_INTL_FALSE@
INCLUDED_INTL_TRUE = @INCLUDED_INTL_TRUE@
INCLUDES = @INCLUDES@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_M4_FALSE = @INSTALL_M4_FALSE@
INSTALL_M4_TRUE = @INSTALL_M4_TRUE@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
INSTOBJEXT = @INSTOBJEXT@
INTLBISON = @INTLBISON@
INTLDIR = @INTLDIR@
INTLLIBS = @INTLLIBS@
INTLOBJS = @INTLOBJS@
INTL_LIBTOOL_SUFFIX_PREFIX = @INTL_LIBTOOL_SUFFIX_PREFIX@
IRIXAL_CFLAGS = @IRIXAL_CFLAGS@
IRIXAL_LIBS = @IRIXAL_LIBS@
IRIXAL_STATIC_LIB = @IRIXAL_STATIC_LIB@
KSTAT_LIBS = @KSTAT_LIBS@
LDFLAGS = @LDFLAGS@
LIBCDIO_CFLAGS = @LIBCDIO_CFLAGS@
LIBCDIO_LIBS = @LIBCDIO_LIBS@
LIBFAME_CFLAGS = @LIBFAME_CFLAGS@
LIBFAME_CONFIG = @LIBFAME_CONFIG@
LIBFAME_LIBS = @LIBFAME_LIBS@
LIBFFMPEG_CFLAGS = @LIBFFMPEG_CFLAGS@
LIBFLAC_CFLAGS = @LIBFLAC_CFLAGS@
LIBFLAC_LIBS = @LIBFLAC_LIBS@
LIBICONV = @LIBICONV@
LIBISO9660_LIBS = @LIBISO9660_LIBS@
LIBMODPLUG_CFLAGS = @LIBMODPLUG_CFLAGS@
LIBMODPLUG_LIBS = @LIBMODPLUG_LIBS@
LIBMPEG2_CFLAGS = @LIBMPEG2_CFLAGS@
LIBNAME = @LIBNAME@
LIBOBJS = @LIBOBJS@
LIBPNG_CONFIG = @LIBPNG_CONFIG@
LIBS = @LIBS@
LIBSMBCLIENT_LIBS = @LIBSMBCLIENT_LIBS@
LIBSTK_CFLAGS = @LIBSTK_CFLAGS@
LIBSTK_LIBS = @LIBSTK_LIBS@
LIBTOOL = $(SHELL) $(top_builddir)/libtool
LIBTOOL_DEPS = @LIBTOOL_DEPS@
LIBVCDINFO_LIBS = @LIBVCDINFO_LIBS@
LIBVCD_CFLAGS = @LIBVCD_CFLAGS@
LIBVCD_LIBS = @LIBVCD_LIBS@
LIBVCD_SYSDEP = @LIBVCD_SYSDEP@
LINUX_CDROM_TIMEOUT = @LINUX_CDROM_TIMEOUT@
LINUX_INCLUDE = @LINUX_INCLUDE@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
LT_AGE = @LT_AGE@
LT_CURRENT = @LT_CURRENT@
LT_REVISION = @LT_REVISION@
MAKEINFO = @MAKEINFO@
MKINSTALLDIRS = @MKINSTALLDIRS@
MKNOD = @MKNOD@
MLIB_CFLAGS = @MLIB_CFLAGS@
MLIB_LIBS = @MLIB_LIBS@
MNG_LIBS = @MNG_LIBS@
MSGFMT = @MSGFMT@
NET_LIBS = @NET_LIBS@
OBJC = @OBJC@
OBJCDEPMODE = @OBJCDEPMODE@
OBJCFLAGS = @OBJCFLAGS@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OGG_CFLAGS = @OGG_CFLAGS@
OGG_LIBS = @OGG_LIBS@
OPENGL_CFLAGS = @OPENGL_CFLAGS@
OPENGL_LIBS = @OPENGL_LIBS@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_VERSION = @PACKAGE_VERSION@
PASS1_CFLAGS = @PASS1_CFLAGS@
PASS2_CFLAGS = @PASS2_CFLAGS@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PNG_CFLAGS = @PNG_CFLAGS@
PNG_LIBS = @PNG_LIBS@
POFILES = @POFILES@
POLYPAUDIO_CFLAGS = @POLYPAUDIO_CFLAGS@
POLYPAUDIO_LIBS = @POLYPAUDIO_LIBS@
POSUB = @POSUB@
PPC_ARCH_FALSE = @PPC_ARCH_FALSE@
PPC_ARCH_TRUE = @PPC_ARCH_TRUE@
RANLIB = @RANLIB@
RT_LIBS = @RT_LIBS@
SDL_CFLAGS = @SDL_CFLAGS@
SDL_CONFIG = @SDL_CONFIG@
SDL_LIBS = @SDL_LIBS@
SET_MAKE = @SET_MAKE@
SGMLTOOLS = @SGMLTOOLS@
SHELL = @SHELL@
SPEC_VERSION = @SPEC_VERSION@
SPEEX_CFLAGS = @SPEEX_CFLAGS@
SPEEX_LIBS = @SPEEX_LIBS@
STATIC = @STATIC@
STRIP = @STRIP@
SUNDGA_CFLAGS = @SUNDGA_CFLAGS@
SUNDGA_LIBS = @SUNDGA_LIBS@
TAR_NAME = @TAR_NAME@
THEORAENC_LIBS = @THEORAENC_LIBS@
THEORAFILE_LIBS = @THEORAFILE_LIBS@
THEORA_CFLAGS = @THEORA_CFLAGS@
THEORA_LIBS = @THEORA_LIBS@
THREAD_CFLAGS = @THREAD_CFLAGS@
THREAD_CFLAGS_CONFIG = @THREAD_CFLAGS_CONFIG@
THREAD_INCLUDES = @THREAD_INCLUDES@
THREAD_LIBS = @THREAD_LIBS@
THREAD_LIBS_CONFIG = @THREAD_LIBS_CONFIG@
USE_INCLUDED_LIBINTL = @USE_INCLUDED_LIBINTL@
USE_NLS = @USE_NLS@
VERSION = @VERSION@
VORBISENC_LIBS = @VORBISENC_LIBS@
VORBISFILE_LIBS = @VORBISFILE_LIBS@
VORBIS_CFLAGS = @VORBIS_CFLAGS@
VORBIS_LIBS = @VORBIS_LIBS@
W32DLL_DEP = @W32DLL_DEP@
W32_NO_OPTIMIZE = @W32_NO_OPTIMIZE@
WIN32_CPPFLAGS = @WIN32_CPPFLAGS@
WIN32_FALSE = @WIN32_FALSE@
WIN32_TRUE = @WIN32_TRUE@
XGETTEXT = @XGETTEXT@
XINE_ACFLAGS = @XINE_ACFLAGS@
XINE_BIN_AGE = @XINE_BIN_AGE@
XINE_BUILD_CC = @XINE_BUILD_CC@
XINE_BUILD_DATE = @XINE_BUILD_DATE@
XINE_BUILD_OS = @XINE_BUILD_OS@
XINE_CONFIG_PREFIX = @XINE_CONFIG_PREFIX@
XINE_DATADIR = @XINE_DATADIR@
XINE_FONTDIR = @XINE_FONTDIR@
XINE_FONTPATH = @XINE_FONTPATH@
XINE_IFACE_AGE = @XINE_IFACE_AGE@
XINE_LOCALEDIR = @XINE_LOCALEDIR@
XINE_LOCALEPATH = @XINE_LOCALEPATH@
XINE_MAJOR = @XINE_MAJOR@
XINE_MINOR = @XINE_MINOR@
XINE_PLUGINDIR = @XINE_PLUGINDIR@
XINE_PLUGINPATH = @XINE_PLUGINPATH@
XINE_PLUGIN_MIN_SYMS = @XINE_PLUGIN_MIN_SYMS@
XINE_SCRIPTPATH = @XINE_SCRIPTPATH@
XINE_SUB = @XINE_SUB@
XVMC_LIB = @XVMC_LIB@
XV_LIB = @XV_LIB@
XXMC_LIB = @XXMC_LIB@
X_CFLAGS = @X_CFLAGS@
X_EXTRA_LIBS = @X_EXTRA_LIBS@
X_LIBS = @X_LIBS@
X_PRE_LIBS = @X_PRE_LIBS@
ZLIB_INCLUDES = @ZLIB_INCLUDES@
ZLIB_LIBS = @ZLIB_LIBS@
ZLIB_LIBS_CONFIG = @ZLIB_LIBS_CONFIG@
ac_ct_AR = @ac_ct_AR@
ac_ct_AS = @ac_ct_AS@
ac_ct_CC = @ac_ct_CC@
ac_ct_CXX = @ac_ct_CXX@
ac_ct_DLLTOOL = @ac_ct_DLLTOOL@
ac_ct_F77 = @ac_ct_F77@
ac_ct_OBJDUMP = @ac_ct_OBJDUMP@
ac_ct_RANLIB = @ac_ct_RANLIB@
ac_ct_STRIP = @ac_ct_STRIP@
am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@
am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@
am__fastdepOBJC_FALSE = @am__fastdepOBJC_FALSE@
am__fastdepOBJC_TRUE = @am__fastdepOBJC_TRUE@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
datadir = @datadir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localstatedir = @localstatedir@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
prefix = @prefix@
program_transform_name = @program_transform_name@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
w32_path = @w32_path@
XINE_LIB = $(top_builddir)/src/xine-engine/libxine.la
noinst_LTLIBRARIES = libxineutils.la
EXTRA_DIST = ppcasm_string.S ppc_asm.tmpl
@HOST_OS_DARWIN_FALSE@@PPC_ARCH_TRUE@pppc_files = ppcasm_string.S
AM_CFLAGS = $(X_CFLAGS)
libxineutils_la_SOURCES = $(pppc_files) \
cpu_accel.c \
color.c \
copy.c \
list.c \
memcpy.c \
monitor.c \
utils.c \
xine_check.c \
xine_mutex.c \
xmllexer.c \
xine_buffer.c \
xmlparser.c
include_HEADERS = \
attributes.h \
compat.h \
xine_buffer.h \
xineutils.h \
xmllexer.h \
xmlparser.h
noinst_HEADERS = ppcasm_string.h xine_check.h
all: all-am
.SUFFIXES:
.SUFFIXES: .S .c .lo .o .obj
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(top_srcdir)/misc/Makefile.common $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
&& exit 0; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/xine-utils/Makefile'; \
cd $(top_srcdir) && \
$(AUTOMAKE) --gnu src/xine-utils/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
clean-noinstLTLIBRARIES:
-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
@list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
test "$$dir" != "$$p" || dir=.; \
echo "rm -f \"$${dir}/so_locations\""; \
rm -f "$${dir}/so_locations"; \
done
libxineutils.la: $(libxineutils_la_OBJECTS) $(libxineutils_la_DEPENDENCIES)
$(LINK) $(libxineutils_la_LDFLAGS) $(libxineutils_la_OBJECTS) $(libxineutils_la_LIBADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/color.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/copy.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cpu_accel.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/list.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcpy.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/monitor.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/utils.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xine_buffer.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xine_check.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xine_mutex.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmllexer.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlparser.Plo@am__quote@
.S.o:
$(CCASCOMPILE) -c $<
.S.obj:
$(CCASCOMPILE) -c `$(CYGPATH_W) '$<'`
.S.lo:
$(LTCCASCOMPILE) -c -o $@ $<
.c.o:
@am__fastdepCC_TRUE@ if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \
@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c $<
.c.obj:
@am__fastdepCC_TRUE@ if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ `$(CYGPATH_W) '$<'`; \
@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ if $(LTCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \
@am__fastdepCC_TRUE@ then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Plo"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
distclean-libtool:
-rm -f libtool
uninstall-info-am:
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$tags $$unique; \
fi
ctags: CTAGS
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
test -z "$(CTAGS_ARGS)$$tags$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$tags $$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& cd $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) $$here
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
$(mkdir_p) $(distdir)/../../misc
@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
list='$(DISTFILES)'; for file in $$list; do \
case $$file in \
$(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
$(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
esac; \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
if test "$$dir" != "$$file" && test "$$dir" != "."; then \
dir="/$$dir"; \
$(mkdir_p) "$(distdir)$$dir"; \
else \
dir=''; \
fi; \
if test -d $$d/$$file; then \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
fi; \
cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
else \
test -f $(distdir)/$$file \
|| cp -p $$d/$$file $(distdir)/$$file \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(LTLIBRARIES) $(HEADERS)
installdirs:
for dir in "$(DESTDIR)$(includedir)"; do \
test -z "$$dir" || $(mkdir_p) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
clean: clean-am
clean-am: clean-generic clean-libtool clean-noinstLTLIBRARIES \
mostlyclean-am
distclean: distclean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-libtool distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
info: info-am
info-am:
install-data-am: install-includeHEADERS
@$(NORMAL_INSTALL)
$(MAKE) $(AM_MAKEFLAGS) install-data-hook
install-exec-am:
install-info: install-info-am
install-man:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-includeHEADERS uninstall-info-am
@$(NORMAL_INSTALL)
$(MAKE) $(AM_MAKEFLAGS) uninstall-hook
.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
clean-libtool clean-noinstLTLIBRARIES ctags distclean \
distclean-compile distclean-generic distclean-libtool \
distclean-tags distdir dvi dvi-am html html-am info info-am \
install install-am install-data install-data-am \
install-data-hook install-exec install-exec-am \
install-includeHEADERS install-info install-info-am \
install-man install-strip installcheck installcheck-am \
installdirs maintainer-clean maintainer-clean-generic \
mostlyclean mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool pdf pdf-am ps ps-am tags uninstall \
uninstall-am uninstall-hook uninstall-includeHEADERS \
uninstall-info-am
$(XINE_LIB):
@cd $(top_srcdir)/src/xine-engine && $(MAKE)
install-data-hook:
@if test $$MAKELEVEL -le 4 ; then \
if test -x "$(top_srcdir)/post-install.sh" ; then \
$(top_srcdir)/post-install.sh ; \
fi \
fi
pass1:
@$(MAKE) MULTIPASS_CFLAGS="$(PASS1_CFLAGS)"
pass2:
@$(MAKE) MULTIPASS_CFLAGS="$(PASS2_CFLAGS)"
debug:
@$(MAKE) CFLAGS="$(DEBUG_CFLAGS)"
install-debug: debug
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
@list='$(SUBDIRS)'; for subdir in $$list; do \
(cd $$subdir && $(MAKE) $@) || exit; \
done;
$(MAKE) $(AM_MAKEFLAGS) install-data-hook
install-includeHEADERS: $(include_HEADERS)
@$(NORMAL_INSTALL)
$(install_sh) -d $(DESTDIR)$(includedir)/xine
@list='$(include_HEADERS)'; for p in $$list; do \
if test -f "$$p"; then d= ; else d="$(srcdir)/"; fi; \
echo " $(INSTALL_DATA) $$d$$p $(DESTDIR)$(includedir)/xine/$$p"; \
$(INSTALL_DATA) $$d$$p $(DESTDIR)$(includedir)/xine/$$p; \
done
uninstall-includeHEADERS:
@$(NORMAL_UNINSTALL)
list='$(include_HEADERS)'; for p in $$list; do \
rm -f $(DESTDIR)$(includedir)/xine/$$p; \
done
uninstall-hook:
@if echo '$(libdir)' | egrep ^'$(XINE_PLUGINDIR)' >/dev/null; then \
list='$(lib_LTLIBRARIES)'; for p in $$list; do \
p="`echo $$p | sed -e 's/\.la$$/\.so/g;s|^.*/||'`"; \
echo " rm -f $(DESTDIR)$(libdir)/$$p"; \
rm -f $(DESTDIR)$(libdir)/$$p; \
done; \
fi
mostlyclean-generic:
-rm -f *~ \#* .*~ .\#*
maintainer-clean-generic:
-@echo "This command is intended for maintainers to use;"
-@echo "it deletes files that may require special tools to rebuild."
-rm -f Makefile.in
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
--- NEW FILE: cpu_accel.c ---
/*
* cpu_accel.c
* Copyright (C) 1999-2001 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
*
* This file is 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <signal.h>
#include <setjmp.h>
#include <dlfcn.h>
#if defined (__SVR4) && defined (__sun)
#include <sys/systeminfo.h>
#endif
#define LOG_MODULE "cpu_accel"
#define LOG_VERBOSE
/*
#define LOG
*/
#include "xineutils.h"
#if defined(ARCH_X86) || defined(ARCH_X86_64)
static jmp_buf sigill_return;
static void sigill_handler (int n) {
longjmp(sigill_return, 1);
}
static uint32_t arch_accel (void)
{
uint32_t caps;
#ifdef __x86_64__
/* 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;
#else
#ifndef _MSC_VER
uint32_t eax, ebx, ecx, edx;
int AMD;
caps = 0;
#ifndef PIC
#define cpuid(op,eax,ebx,ecx,edx) \
__asm__ ("cpuid" \
: "=a" (eax), \
"=b" (ebx), \
"=c" (ecx), \
"=d" (edx) \
: "a" (op) \
: "cc")
#else /* PIC version : save ebx */
#define cpuid(op,eax,ebx,ecx,edx) \
__asm__ ("pushl %%ebx\n\t" \
"cpuid\n\t" \
"movl %%ebx,%1\n\t" \
"popl %%ebx" \
: "=a" (eax), \
"=r" (ebx), \
"=c" (ecx), \
"=d" (edx) \
: "a" (op) \
: "cc")
#endif
__asm__ ("pushfl\n\t"
"pushfl\n\t"
"popl %0\n\t"
"movl %0,%1\n\t"
"xorl $0x200000,%0\n\t"
"pushl %0\n\t"
"popfl\n\t"
"pushfl\n\t"
"popl %0\n\t"
"popfl"
: "=r" (eax),
"=r" (ebx)
:
: "cc");
if (eax == ebx) {
/* no cpuid */
return 0;
}
cpuid (0x00000000, eax, ebx, ecx, edx);
if (!eax) {
/* vendor string only */
return 0;
}
AMD = (ebx == 0x68747541) && (ecx == 0x444d4163) && (edx == 0x69746e65);
cpuid (0x00000001, eax, ebx, ecx, edx);
if (edx & 0x00800000) {
/* MMX */
caps |= MM_ACCEL_X86_MMX;
}
if (edx & 0x02000000) {
/* SSE - identical to AMD MMX extensions */
caps |= MM_ACCEL_X86_SSE | MM_ACCEL_X86_MMXEXT;
}
if (edx & 0x04000000) {
/* SSE2 */
caps |= MM_ACCEL_X86_SSE2;
}
cpuid (0x80000000, eax, ebx, ecx, edx);
if (eax >= 0x80000001) {
cpuid (0x80000001, eax, ebx, ecx, edx);
if (edx & 0x80000000) {
/* AMD 3DNow extensions */
caps |= MM_ACCEL_X86_3DNOW;
}
if (AMD && (edx & 0x00400000)) {
/* AMD MMX extensions */
caps |= MM_ACCEL_X86_MMXEXT;
}
}
#else
caps = 0;
#endif /* _MSC_VER */
/* test OS support for SSE */
if (caps & MM_ACCEL_X86_SSE) {
void (*old_sigill_handler)(int);
old_sigill_handler = signal (SIGILL, sigill_handler);
if (setjmp(sigill_return)) {
lprintf("OS doesn't support SSE instructions.\n");
caps &= ~(MM_ACCEL_X86_SSE|MM_ACCEL_X86_SSE2);
} else {
__asm__ volatile ("xorps %xmm0, %xmm0");
}
signal(SIGILL, old_sigill_handler);
}
#endif /* x86_64 */
return caps;
}
#endif /* ARCH_X86 */
#if defined(ARCH_PPC) && defined(ENABLE_ALTIVEC)
static sigjmp_buf jmpbuf;
static volatile sig_atomic_t canjump = 0;
static void sigill_handler (int sig)
{
if (!canjump) {
signal (sig, SIG_DFL);
raise (sig);
}
canjump = 0;
siglongjmp (jmpbuf, 1);
}
static uint32_t arch_accel (void)
{
/* FIXME: Autodetect cache line size via AUX ELF vector or otherwise */
uint32_t flags = MM_ACCEL_PPC_CACHE32;
signal (SIGILL, sigill_handler);
if (sigsetjmp (jmpbuf, 1)) {
signal (SIGILL, SIG_DFL);
return flags;
}
canjump = 1;
#ifndef HOST_OS_DARWIN
__asm__ volatile ("mtspr 256, %0\n\t"
"vand %%v0, %%v0, %%v0"
:
: "r" (-1));
#else
__asm__ volatile ("mtspr 256, r0\n\t"
"vand v0, v0, v0"
:
: "r" (-1));
#endif
signal (SIGILL, SIG_DFL);
return flags|MM_ACCEL_PPC_ALTIVEC;
}
#endif /* ARCH_PPC */
#if defined(ARCH_SPARC) && defined(ENABLE_VIS)
#if defined (__SVR4) && defined (__sun)
static uint32_t arch_accel (void)
{
uint32_t flags = 0;
long len;
char isalist_[257], *isalist, *s1, *last, *token;
len = sysinfo(SI_ISALIST, isalist_, 257);
if (len > 257) {
isalist = malloc(len);
sysinfo(SI_ISALIST, isalist, len);
}
else {
isalist = isalist_;
}
s1 = isalist;
while (token = strtok_r(s1, " ", &last)) {
if (strlen(token) > 4) {
if (strcmp(token + (strlen(token) - 4), "+vis") == 0) {
flags |= MM_ACCEL_SPARC_VIS;
}
}
if (strlen(token) > 5) {
if (strcmp(token + (strlen(token) - 5), "+vis2") == 0) {
flags |= MM_ACCEL_SPARC_VIS2;
}
}
s1 = NULL;
}
if (isalist != isalist_) {
free(isalist);
}
return flags;
}
#else
static sigjmp_buf jmpbuf;
static volatile sig_atomic_t canjump = 0;
static void sigill_handler (int sig)
{
if (!canjump) {
signal(sig, SIG_DFL);
raise(sig);
}
canjump = 0;
siglongjmp(jmpbuf, 1);
}
static uint32_t arch_accel (void)
{
uint32_t flags = 0;
signal(SIGILL, sigill_handler);
if (sigsetjmp(jmpbuf, 1)) {
signal(SIGILL, SIG_DFL);
return flags;
}
canjump = 1;
/* pdist %f0, %f0, %f0 */
__asm__ __volatile__(".word\t0x81b007c0");
canjump = 0;
flags |= MM_ACCEL_SPARC_VIS;
if (sigsetjmp(jmpbuf, 1)) {
signal(SIGILL, SIG_DFL);
return flags;
}
canjump = 1;
/* edge8n %g0, %g0, %g0 */
__asm__ __volatile__(".word\t0x81b00020");
canjump = 0;
flags |= MM_ACCEL_SPARC_VIS2;
signal(SIGILL, SIG_DFL);
return flags;
}
#endif
#endif /* ARCH_SPARC */
uint32_t xine_mm_accel (void)
{
static int initialized = 0;
static uint32_t accel = 0;
if (!initialized) {
#ifdef HAVE_MLIB
#ifdef MLIB_LAZYLOAD
void *hndl;
if ((hndl = dlopen("libmlib.so.2", RTLD_LAZY | RTLD_GLOBAL | RTLD_NODELETE)) != NULL) {
dlclose(hndl);
accel |= MM_ACCEL_MLIB;
}
#else
accel |= MM_ACCEL_MLIB;
#endif
#endif
#if defined(ARCH_X86) || (defined(ARCH_PPC) && defined(ENABLE_ALTIVEC)) || (defined(ARCH_SPARC) && defined(ENABLE_VIS))
accel |= arch_accel();
#endif
if(getenv("XINE_NO_ACCEL")) {
accel = 0;
}
initialized = 1;
}
return accel;
}
--- NEW FILE: xineutils.h ---
/*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
[...1009 lines suppressed...]
/*
* guess default encoding for the subtitles
*/
const char *xine_guess_spu_encoding(void);
#if defined(__CYGWIN__) || defined(WIN32)
char *exec_path_append_subdir(char * string);
#endif
/*
* 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);
#ifdef __cplusplus
}
#endif
#endif
--- NEW FILE: attributes.h ---
/*
* attributes.h
* Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
*
* This file is 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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
#endif /* ATTRIBUTE_H_ */