diff options
Diffstat (limited to 'win32/include/xine')
| -rw-r--r-- | win32/include/xine/attributes.h | 44 | ||||
| -rw-r--r-- | win32/include/xine/compat.h | 58 | ||||
| -rw-r--r-- | win32/include/xine/xine.h | 1580 | ||||
| -rw-r--r-- | win32/include/xine/xineutils.h | 957 |
4 files changed, 2639 insertions, 0 deletions
diff --git a/win32/include/xine/attributes.h b/win32/include/xine/attributes.h new file mode 100644 index 000000000..eac90ea9e --- /dev/null +++ b/win32/include/xine/attributes.h @@ -0,0 +1,44 @@ +/*
+ * 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__)
+#ifndef ATTRIBUTE_PACKED
+#define ATTRIBUTE_PACKED 1
+#endif
+#else
+#undef ATTRIBUTE_PACKED
+#define __attribute__(x) /**/
+#endif
+
+#endif /* ATTRIBUTE_H_ */
+
diff --git a/win32/include/xine/compat.h b/win32/include/xine/compat.h new file mode 100644 index 000000000..6c2906f14 --- /dev/null +++ b/win32/include/xine/compat.h @@ -0,0 +1,58 @@ +/*
+ * 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 2003/04/20 16:42:10 guenter 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
diff --git a/win32/include/xine/xine.h b/win32/include/xine/xine.h new file mode 100644 index 000000000..193d7b7a9 --- /dev/null +++ b/win32/include/xine/xine.h @@ -0,0 +1,1580 @@ +/*
+ * Copyright (C) 2000-2002 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.h,v 1.1 2003/04/20 16:42:10 guenter Exp $
+ *
+ * public xine-lib (libxine) interface and documentation
+ *
+ *
+ * some programming guidelines about this api:
+ * -------------------------------------------
+ *
+ * (1) libxine has (per stream instance) a fairly static memory
+ * model
+ * (2) as a rule of thumb, never free() or realloc() any pointers
+ * returned by the xine engine (unless stated otherwise)
+ * or, in other words:
+ * do not free() stuff you have not malloc()ed
+ * (3) xine is multi-threaded, make sure your programming environment
+ * can handle this.
+ * for x11-related stuff this means that you either have to properly
+ * use xlockdisplay() or use two seperate connections to the x-server
+ *
+ */
+
+#ifndef HAVE_XINE_H
+#define HAVE_XINE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <sys/time.h>
+#include <time.h>
+
+
+/*********************************************************************
+ * xine opaque data types *
+ *********************************************************************/
+
+typedef struct xine_s xine_t;
+typedef struct xine_stream_s xine_stream_t;
+typedef struct xine_audio_port_s xine_audio_port_t;
+typedef struct xine_video_port_s xine_video_port_t;
+
+/* convenience types: simple player UIs might want to call ports drivers */
+typedef xine_audio_port_t xine_ao_driver_t;
+typedef xine_video_port_t xine_vo_driver_t;
+
+
+/*********************************************************************
+ * global engine handling *
+ *********************************************************************/
+
+/*
+ * version information
+ */
+
+/* dynamic info from actually linked libxine */
+const char *xine_get_version_string (void);
+void xine_get_version (int *major, int *minor, int *sub);
+
+/* compare given version to libxine version,
+ return 1 if compatible, 0 otherwise */
+int xine_check_version (int major, int minor, int sub) ;
+
+/* static info - which libxine release this header came from */
+#define XINE_MAJOR_VERSION 1
+#define XINE_MINOR_VERSION 0
+#define XINE_SUB_VERSION 0
+#define XINE_VERSION "1-beta10"
+
+/*
+ * pre-init the xine engine
+ *
+ * will first malloc and init a xine_t, create an empty config
+ * system, then scan through all installed plugins and add them
+ * to an internal list for later use.
+ *
+ * to fully init the xine engine, you have to load config values
+ * (either using your own storage method and calling
+ * xine_config_register_entry, or by using the xine_load_config
+ * utility function - see below) and then call xine_init
+ *
+ * the only proper way to shut down the xine engine is to
+ * call xine_exit() - do not try to free() the xine pointer
+ * yourself and do not try to access any internal data structures
+ */
+xine_t *xine_new (void);
+
+/*
+ * post_init the xine engine
+ */
+void xine_init (xine_t *self);
+
+/*
+ * helper functions to find and init audio/video drivers
+ * from xine's plugin collection
+ *
+ * id : identifier of the driver, may be NULL for auto-detection
+ * data : special data struct for ui/driver communications, depends
+ * on driver
+ * visual: video driver flavor selector, constants see below
+ *
+ * both functions may return NULL if driver failed to load, was not
+ * found ...
+ *
+ * use xine_close_audio/video_driver() to close loaded drivers
+ * and free resources allocated by them
+ */
+xine_audio_port_t *xine_open_audio_driver (xine_t *self, const char *id,
+ void *data);
+xine_video_port_t *xine_open_video_driver (xine_t *self, const char *id,
+ int visual, void *data);
+
+void xine_close_audio_driver (xine_t *self, xine_audio_port_t *driver);
+void xine_close_video_driver (xine_t *self, xine_video_port_t *driver);
+
+/* valid visual types */
+#define XINE_VISUAL_TYPE_NONE 0
+#define XINE_VISUAL_TYPE_X11 1
+#define XINE_VISUAL_TYPE_AA 2
+#define XINE_VISUAL_TYPE_FB 3
+#define XINE_VISUAL_TYPE_GTK 4
+#define XINE_VISUAL_TYPE_DFB 5
+#define XINE_VISUAL_TYPE_PM 6 /* used by the OS/2 port */
+#define XINE_VISUAL_TYPE_WIN32 7 /* used by the WIN32/_MSC_VER port */
+
+/*
+ * free all resources, close all plugins, close engine.
+ * self pointer is no longer valid after this call.
+ */
+void xine_exit (xine_t *self);
+
+
+/*********************************************************************
+ * stream handling *
+ *********************************************************************/
+
+/*
+ * create a new stream for media playback/access
+ *
+ * returns xine_stream_t* if OK,
+ * NULL on error (use xine_get_error for details)
+ *
+ * the only proper way to free the stream pointer returned by this
+ * function is to call xine_dispose() on it. do not try to access any
+ * fields in xine_stream_t, they're all private and subject to change
+ * without further notice.
+ */
+xine_stream_t *xine_stream_new (xine_t *self,
+ xine_audio_port_t *ao, xine_video_port_t *vo);
+
+/*
+ * Make one stream the slave of another.
+ * This establishes a binary master slave relation on streams, where
+ * certain operations (specified by parameter "affection") on the master
+ * stream are also applied to the slave stream.
+ * If you want more than one stream to react to one master, you have to
+ * apply the calls in a top down way:
+ * xine_stream_master_slave(stream1, stream2, 3);
+ * xine_stream_master_slave(stream2, stream3, 3);
+ * This will make stream1 affect stream2 and stream2 affect stream3, so
+ * effectively, operations on stream1 propagate to stream2 and 3.
+ *
+ * Please note that subsequent master_slave calls on the same streams
+ * will overwrite their previous master/slave setting.
+ * Be sure to not mess around.
+ *
+ * returns 1 on success, 0 on failure
+ */
+int xine_stream_master_slave(xine_stream_t *master, xine_stream_t *slave,
+ int affection);
+
+/* affection is some of the following ORed together: */
+/* playing the master plays the slave */
+#define XINE_MASTER_SLAVE_PLAY (1<<0)
+/* slave stops on master stop */
+#define XINE_MASTER_SLAVE_STOP (1<<1)
+
+/*
+ * open a stream
+ *
+ * look for input / demux / decoder plugins, find out about the format
+ * see if it is supported, set up internal buffers and threads
+ *
+ * returns 1 if OK, 0 on error (use xine_get_error for details)
+ */
+int xine_open (xine_stream_t *stream, const char *mrl);
+
+/*
+ * play a stream from a given position
+ *
+ * start_pos: 0..65535
+ * start_time: milliseconds
+ * if both start position parameters are != 0 start_pos will be used
+ * for non-seekable streams both values will be ignored
+ *
+ * returns 1 if OK, 0 on error (use xine_get_error for details)
+ */
+int xine_play (xine_stream_t *stream, int start_pos, int start_time);
+
+/*
+ * set xine to a trick mode for fast forward, backwards playback,
+ * low latency seeking. Please note that this works only with some
+ * input plugins. mode constants see below.
+ *
+ * returns 1 if OK, 0 on error (use xine_get_error for details)
+ */
+int xine_trick_mode (xine_stream_t *stream, int mode, int value);
+
+/* trick modes */
+#define XINE_TRICK_MODE_OFF 0
+#define XINE_TRICK_MODE_SEEK_TO_POSITION 1
+#define XINE_TRICK_MODE_SEEK_TO_TIME 2
+#define XINE_TRICK_MODE_FAST_FORWARD 3
+#define XINE_TRICK_MODE_FAST_REWIND 4
+
+/*
+ * stop stream playback
+ * xine_stream_t stays valid for new xine_open or xine_play
+ */
+void xine_stop (xine_stream_t *stream);
+
+/*
+ * stop stream playback, free all stream-related resources
+ * xine_stream_t stays valid for new xine_open
+ */
+void xine_close (xine_stream_t *stream);
+
+/*
+ * ask current/recent input plugin to eject media - may or may not work,
+ * depending on input plugin capabilities
+ */
+int xine_eject (xine_stream_t *stream);
+
+/*
+ * stop playback, dispose all stream-related resources
+ * xine_stream_t no longer valid when after this
+ */
+void xine_dispose (xine_stream_t *stream);
+
+/*
+ * set/get engine parameters.
+ */
+void xine_engine_set_param(xine_t *self, int param, int value);
+int xine_engine_get_param(xine_t *self, int param);
+
+#define XINE_ENGINE_PARAM_VERBOSITY 1
+
+/*
+ * set/get xine stream parameters
+ * e.g. playback speed, constants see below
+ */
+void xine_set_param (xine_stream_t *stream, int param, int value);
+int xine_get_param (xine_stream_t *stream, int param);
+
+/*
+ * xine engine parameters
+ */
+#define XINE_PARAM_SPEED 1 /* see below */
+#define XINE_PARAM_AV_OFFSET 2 /* unit: 1/90000 sec */
+#define XINE_PARAM_AUDIO_CHANNEL_LOGICAL 3 /* -1 => auto, -2 => off */
+#define XINE_PARAM_SPU_CHANNEL 4
+#define XINE_PARAM_VIDEO_CHANNEL 5
+#define XINE_PARAM_AUDIO_VOLUME 6 /* 0..100 */
+#define XINE_PARAM_AUDIO_MUTE 7 /* 1=>mute, 0=>unmute */
+#define XINE_PARAM_AUDIO_COMPR_LEVEL 8 /* <100=>off, % compress otherw*/
+#define XINE_PARAM_AUDIO_AMP_LEVEL 9 /* 0..200, 100=>100% (default) */
+#define XINE_PARAM_AUDIO_REPORT_LEVEL 10 /* 1=>send events, 0=> don't */
+#define XINE_PARAM_VERBOSITY 11 /* control console output */
+#define XINE_PARAM_SPU_OFFSET 12 /* unit: 1/90000 sec */
+#define XINE_PARAM_IGNORE_VIDEO 13 /* disable video decoding */
+#define XINE_PARAM_IGNORE_AUDIO 14 /* disable audio decoding */
+#define XINE_PARAM_IGNORE_SPU 15 /* disable spu decoding */
+#define XINE_PARAM_ENABLE_BROADCAST 16 /* (not implemented yet) */
+#define XINE_PARAM_METRONOM_PREBUFFER 17 /* unit: 1/90000 sec */
+
+
+/* speed values */
+#define XINE_SPEED_PAUSE 0
+#define XINE_SPEED_SLOW_4 1
+#define XINE_SPEED_SLOW_2 2
+#define XINE_SPEED_NORMAL 4
+#define XINE_SPEED_FAST_2 8
+#define XINE_SPEED_FAST_4 16
+
+/* video parameters */
+#define XINE_PARAM_VO_DEINTERLACE 0x01000000 /* bool */
+#define XINE_PARAM_VO_ASPECT_RATIO 0x01000001 /* see below */
+#define XINE_PARAM_VO_HUE 0x01000002 /* 0..65535 */
+#define XINE_PARAM_VO_SATURATION 0x01000003 /* 0..65535 */
+#define XINE_PARAM_VO_CONTRAST 0x01000004 /* 0..65535 */
+#define XINE_PARAM_VO_BRIGHTNESS 0x01000005 /* 0..65535 */
+#define XINE_PARAM_VO_ZOOM_X 0x01000008 /* percent */
+#define XINE_PARAM_VO_ZOOM_Y 0x0100000d /* percent */
+#define XINE_PARAM_VO_PAN_SCAN 0x01000009 /* bool */
+#define XINE_PARAM_VO_TVMODE 0x0100000a /* ??? */
+
+#define XINE_VO_ZOOM_STEP 100
+#define XINE_VO_ZOOM_MAX 400
+#define XINE_VO_ZOOM_MIN -85
+
+/* possible ratios for XINE_PARAM_VO_ASPECT_RATIO */
+#define XINE_VO_ASPECT_AUTO 0
+#define XINE_VO_ASPECT_SQUARE 1 /* 1:1 */
+#define XINE_VO_ASPECT_4_3 2 /* 4:3 */
+#define XINE_VO_ASPECT_ANAMORPHIC 3 /* 16:9 */
+#define XINE_VO_ASPECT_DVB 4 /* 1:2 */
+#define XINE_VO_ASPECT_NUM_RATIOS 5
+#define XINE_VO_ASPECT_PAN_SCAN 41
+#define XINE_VO_ASPECT_DONT_TOUCH 42
+
+/* stream format detection strategies */
+
+/* recognize stream type first by content then by extension. */
+#define XINE_DEMUX_DEFAULT_STRATEGY 0
+/* recognize stream type first by extension then by content. */
+#define XINE_DEMUX_REVERT_STRATEGY 1
+/* recognize stream type by content only. */
+#define XINE_DEMUX_CONTENT_STRATEGY 2
+/* recognize stream type by extension only. */
+#define XINE_DEMUX_EXTENSION_STRATEGY 3
+
+/* verbosity settings */
+#define XINE_VERBOSITY_NONE 0
+#define XINE_VERBOSITY_LOG 1
+#define XINE_VERBOSITY_DEBUG 2
+
+/*
+ * snapshot function
+ *
+ * image format can be YUV 4:2:0 or 4:2:2
+ * will copy the image data into memory that <img> points to
+ * (interleaved for yuv 4:2:2 or planary for 4:2:0)
+ *
+ * returns 1 on success, 0 failure.
+ */
+int xine_get_current_frame (xine_stream_t *stream,
+ int *width, int *height,
+ int *ratio_code, int *format,
+ uint8_t *img);
+
+/* xine image formats */
+#define XINE_IMGFMT_YV12 (('2'<<24)|('1'<<16)|('V'<<8)|'Y')
+#define XINE_IMGFMT_YUY2 (('2'<<24)|('Y'<<16)|('U'<<8)|'Y')
+
+
+/*********************************************************************
+ * media processing *
+ *********************************************************************/
+
+#ifdef XINE_ENABLE_EXPERIMENTAL_FEATURES
+
+/*
+ * access to decoded audio and video frames from a stream
+ * these functions are intended to provide the basis for
+ * re-encoding and other video processing applications
+ *
+ * warning: highly experimental
+ *
+ */
+
+xine_video_port_t *xine_new_framegrab_video_port (xine_t *self);
+
+typedef struct {
+
+ int64_t vpts; /* timestamp 1/90000 sec for a/v sync */
+ int64_t duration;
+ int width, height;
+ int colorspace; /* XINE_IMGFMT_* */
+ double aspect_ratio;
+
+ int pos_stream; /* bytes from stream start */
+ int pos_time; /* milliseconds */
+
+ uint8_t *data;
+ void *xine_frame; /* used internally by xine engine */
+} xine_video_frame_t;
+
+int xine_get_next_video_frame (xine_video_port_t *port,
+ xine_video_frame_t *frame);
+
+void xine_free_video_frame (xine_video_port_t *port, xine_video_frame_t *frame);
+
+xine_audio_port_t *xine_new_framegrab_audio_port (xine_t *self);
+
+typedef struct {
+
+ int64_t vpts; /* timestamp 1/90000 sec for a/v sync */
+ int num_samples;
+ int sample_rate;
+ int num_channels;
+ int bits_per_sample; /* per channel */
+
+ off_t pos_stream; /* bytes from stream start */
+ int pos_time; /* milliseconds */
+
+ uint8_t *data;
+ void *xine_frame; /* used internally by xine engine */
+} xine_audio_frame_t;
+
+int xine_get_next_audio_frame (xine_audio_port_t *port,
+ xine_audio_frame_t *frame);
+
+void xine_free_audio_frame (xine_audio_port_t *port, xine_audio_frame_t *frame);
+
+ /*
+ * maybe future aproach:
+ */
+
+int xine_get_video_frame (xine_stream_t *stream,
+ int timestamp, /* msec */
+ int *width, int *height,
+ int *ratio_code,
+ int *duration, /* msec */
+ int *format,
+ uint8_t *img);
+
+/* TODO: xine_get_audio_frame */
+
+#endif
+
+
+/*********************************************************************
+ * post plugin handling *
+ *********************************************************************/
+
+/*
+ * post effect plugin functions
+ *
+ * after the data leaves the decoder it can pass an arbitrary tree
+ * of post plugins allowing for effects to be applied to the video
+ * frames/audio buffers before they reach the output stage
+ */
+
+typedef struct xine_post_s xine_post_t;
+
+struct xine_post_s {
+
+ /* a NULL-terminated array of audio input ports this post plugin
+ * provides; you can hand these to other post plugin's outputs or
+ * pass them to the initialization of streams
+ */
+ xine_audio_port_t **audio_input;
+
+ /* a NULL-terminated array of video input ports this post plugin
+ * provides; you can hand these to other post plugin's outputs or
+ * pass them to the initialization of streams
+ */
+ xine_video_port_t **video_input;
+
+ /* the type of the post plugin
+ * one of XINE_POST_TYPE_* can be used here
+ */
+ int type;
+
+};
+
+/*
+ * initialize a post plugin
+ *
+ * returns xine_post_t* on success, NULL on failure
+ *
+ * Initializes the post plugin with the given name and connects its
+ * outputs to the NULL-terminated arrays of audio and video ports.
+ * Some plugins also care about the number of inputs you request
+ * (e.g. mixer plugins), others simply ignore this number.
+ */
+xine_post_t *xine_post_init(xine_t *xine, const char *name,
+ int inputs,
+ xine_audio_port_t **audio_target,
+ xine_video_port_t **video_target);
+
+/* get a list of all available post plugins */
+const char *const *xine_list_post_plugins(xine_t *xine);
+
+/* get a list of all post plugins of one type */
+const char *const *xine_list_post_plugins_typed(xine_t *xine, int type);
+
+/*
+ * post plugin input/output
+ *
+ * These structures encapsulate inputs/outputs for post plugins
+ * to transfer arbitrary data. Frontends can also provide inputs
+ * and outputs and connect them to post plugins to exchange data
+ * with them.
+ */
+
+typedef struct xine_post_in_s xine_post_in_t;
+typedef struct xine_post_out_s xine_post_out_t;
+
+struct xine_post_in_s {
+
+ /* the name identifying this input */
+ const char *name;
+
+ /* the datatype of this input, use one of XINE_POST_DATA_* here */
+ int type;
+
+ /* the data pointer; input is directed to this memory location,
+ * so you simply access the pointer to access the input data */
+ void *data;
+
+};
+
+struct xine_post_out_s {
+
+ /* the name identifying this output */
+ const char *name;
+
+ /* the datatype of this output, use one of XINE_POST_DATA_* here */
+ int type;
+
+ /* the data pointer; output should be directed to this memory location,
+ * so in the easy case you simply write through the pointer */
+ void *data;
+
+ /* this function is called, when the output should be redirected
+ * to another input, you sould set the data pointer to direct
+ * any output to this new input;
+ * a special situation is, when this function is called with a NULL
+ * argument: in this case you should disconnect the data pointer
+ * from any output and if necessary to avoid writing to some stray
+ * memory you should make it point to some dummy location,
+ * returns 1 on success, 0 on failure;
+ * if you do not implement rewiring, set this to NULL */
+ int (*rewire) (xine_post_out_t *self, void *data);
+
+};
+
+/* get a list of all inputs of a post plugin */
+const char *const *xine_post_list_inputs(xine_post_t *self);
+
+/* get a list of all outputs of a post plugin */
+const char *const *xine_post_list_outputs(xine_post_t *self);
+
+/* retrieve one specific input of a post plugin */
+const xine_post_in_t *xine_post_input(xine_post_t *self, char *name);
+
+/* retrieve one specific output of a post plugin */
+const xine_post_out_t *xine_post_output(xine_post_t *self, char *name);
+
+/*
+ * wire an input to an output
+ * returns 1 on success, 0 on failure
+ */
+int xine_post_wire(xine_post_out_t *source, xine_post_in_t *target);
+
+/*
+ * wire a video port to a video output
+ * This can be used to rewire different post plugins to the video output
+ * plugin layer. The ports you hand in at xine_post_init() will already
+ * be wired with the post plugin, so you need this function for
+ * _re_connecting only.
+ *
+ * returns 1 on success, 0 on failure
+ */
+int xine_post_wire_video_port(xine_post_out_t *source, xine_video_port_t *vo);
+
+/*
+ * wire an audio port to an audio output
+ * This can be used to rewire different post plugins to the audio output
+ * plugin layer. The ports you hand in at xine_post_init() will already
+ * be wired with the post plugin, so you need this function for
+ * _re_connecting only.
+ *
+ * returns 1 on success, 0 on failure
+ */
+int xine_post_wire_audio_port(xine_post_out_t *source, xine_audio_port_t *vo);
+
+/*
+ * Extracts an output for a stream. Use this to rewire the outputs of streams.
+ */
+xine_post_out_t * xine_get_video_source(xine_stream_t *stream);
+xine_post_out_t * xine_get_audio_source(xine_stream_t *stream);
+
+/*
+ * disposes the post plugin
+ * please make sure that no other post plugin and no stream is
+ * connected to any of this plugin's inputs
+ */
+void xine_post_dispose(xine_t *xine, xine_post_t *self);
+
+
+/* post plugin types */
+#define XINE_POST_TYPE_VIDEO_FILTER 0x010000
+#define XINE_POST_TYPE_VIDEO_VISUALIZATION 0x010001
+#define XINE_POST_TYPE_VIDEO_COMPOSE 0x010002
+#define XINE_POST_TYPE_AUDIO_FILTER 0x020000
+#define XINE_POST_TYPE_AUDIO_VISUALIZATION 0x020001
+
+
+/* post plugin data types */
+
+/* video port data
+ * input->data is a xine_video_port_t*
+ * output->data usually is a xine_video_port_t**
+ */
+#define XINE_POST_DATA_VIDEO 0
+
+/* audio port data
+ * input->data is a xine_audio_port_t*
+ * output->data usually is a xine_audio_port_t**
+ */
+#define XINE_POST_DATA_AUDIO 1
+
+/* integer data
+ * input->data is a int*
+ * output->data usually is a int*
+ */
+#define XINE_POST_DATA_INT 3
+
+/* double precision floating point data
+ * input->data is a double*
+ * output->data usually is a double*
+ */
+#define XINE_POST_DATA_DOUBLE 4
+
+
+/*********************************************************************
+ * information retrieval *
+ *********************************************************************/
+
+/*
+ * xine log functions
+ *
+ * frontends can display xine log output using these functions
+ */
+int xine_get_log_section_count(xine_t *self);
+
+/* return a NULL terminated array of log sections names */
+const char *const *xine_get_log_names(xine_t *self);
+
+/* print some log information to <buf> section */
+void xine_log (xine_t *self, int buf,
+ const char *format, ...);
+
+/* get log messages of specified section */
+const char *const *xine_get_log (xine_t *self, int buf);
+
+/* log callback will be called whenever something is logged */
+typedef void (*xine_log_cb_t) (void *user_data, int section);
+void xine_register_log_cb (xine_t *self, xine_log_cb_t cb,
+ void *user_data);
+
+/*
+ * error handling / engine status
+ */
+
+/* return last error */
+int xine_get_error (xine_stream_t *stream);
+
+/* get current xine engine status (constants see below) */
+int xine_get_status (xine_stream_t *stream);
+
+/*
+ * engine status codes
+ */
+#define XINE_STATUS_IDLE 0 /* no mrl assigned */
+#define XINE_STATUS_STOP 1
+#define XINE_STATUS_PLAY 2
+#define XINE_STATUS_QUIT 3
+
+/*
+ * xine error codes
+ */
+#define XINE_ERROR_NONE 0
+#define XINE_ERROR_NO_INPUT_PLUGIN 1
+#define XINE_ERROR_NO_DEMUX_PLUGIN 2
+#define XINE_ERROR_DEMUX_FAILED 3
+#define XINE_ERROR_MALFORMED_MRL 4
+
+/*
+ * try to find out audio/spu language of given channel
+ * (use -1 for current channel)
+ *
+ * returns 1 on success, 0 on failure
+ */
+int xine_get_audio_lang (xine_stream_t *stream, int channel,
+ char *lang);
+int xine_get_spu_lang (xine_stream_t *stream, int channel,
+ char *lang);
+
+/*
+ * get position / length information
+ *
+ * depending of the nature and system layer of the stream,
+ * some or all of this information may be unavailable or incorrect
+ * (e.g. live network streams may not have a valid length)
+ *
+ * returns 1 on success, 0 on failure (data was not updated,
+ * probably because it's not known yet... try again later)
+ */
+int xine_get_pos_length (xine_stream_t *stream,
+ int *pos_stream, /* 0..65535 */
+ int *pos_time, /* milliseconds */
+ int *length_time);/* milliseconds */
+
+/*
+ * get information about the stream such as
+ * video width/height, codecs, audio format, title, author...
+ *
+ * constants see below
+ */
+uint32_t xine_get_stream_info (xine_stream_t *stream, int info);
+const char *xine_get_meta_info (xine_stream_t *stream, int info);
+
+/* xine_get_stream_info */
+#define XINE_STREAM_INFO_BITRATE 0
+#define XINE_STREAM_INFO_SEEKABLE 1
+#define XINE_STREAM_INFO_VIDEO_WIDTH 2
+#define XINE_STREAM_INFO_VIDEO_HEIGHT 3
+#define XINE_STREAM_INFO_VIDEO_RATIO 4 /* *10000 */
+#define XINE_STREAM_INFO_VIDEO_CHANNELS 5
+#define XINE_STREAM_INFO_VIDEO_STREAMS 6
+#define XINE_STREAM_INFO_VIDEO_BITRATE 7
+#define XINE_STREAM_INFO_VIDEO_FOURCC 8
+#define XINE_STREAM_INFO_VIDEO_HANDLED 9 /* codec available? */
+#define XINE_STREAM_INFO_FRAME_DURATION 10 /* 1/90000 sec */
+#define XINE_STREAM_INFO_AUDIO_CHANNELS 11
+#define XINE_STREAM_INFO_AUDIO_BITS 12
+#define XINE_STREAM_INFO_AUDIO_SAMPLERATE 13
+#define XINE_STREAM_INFO_AUDIO_BITRATE 14
+#define XINE_STREAM_INFO_AUDIO_FOURCC 15
+#define XINE_STREAM_INFO_AUDIO_HANDLED 16 /* codec available? */
+#define XINE_STREAM_INFO_HAS_CHAPTERS 17
+#define XINE_STREAM_INFO_HAS_VIDEO 18
+#define XINE_STREAM_INFO_HAS_AUDIO 19
+#define XINE_STREAM_INFO_IGNORE_VIDEO 20
+#define XINE_STREAM_INFO_IGNORE_AUDIO 21
+#define XINE_STREAM_INFO_IGNORE_SPU 22
+#define XINE_STREAM_INFO_VIDEO_HAS_STILL 23
+#define XINE_STREAM_INFO_MAX_AUDIO_CHANNEL 24
+#define XINE_STREAM_INFO_MAX_SPU_CHANNEL 25
+#define XINE_STREAM_INFO_AUDIO_MODE 26
+
+/* xine_get_meta_info */
+#define XINE_META_INFO_TITLE 0
+#define XINE_META_INFO_COMMENT 1
+#define XINE_META_INFO_ARTIST 2
+#define XINE_META_INFO_GENRE 3
+#define XINE_META_INFO_ALBUM 4
+#define XINE_META_INFO_YEAR 5
+#define XINE_META_INFO_VIDEOCODEC 6
+#define XINE_META_INFO_AUDIOCODEC 7
+#define XINE_META_INFO_SYSTEMLAYER 8
+#define XINE_META_INFO_INPUT_PLUGIN 9
+
+
+/*********************************************************************
+ * plugin management / autoplay / mrl browsing *
+ *********************************************************************/
+
+/*
+ * note: the pointers to strings or string arrays returned
+ * by some of these functions are pointers to statically
+ * alloced internal xine memory chunks.
+ * they're only valid between xine function calls
+ * and should never be free()d.
+ */
+
+typedef struct {
+ char *origin; /* file plugin: path */
+ char *mrl; /* <type>://<location> */
+ char *link;
+ uint32_t type; /* see below */
+ off_t size; /* size of this source, may be 0 */
+} xine_mrl_t;
+
+/* mrl types */
+#define XINE_MRL_TYPE_unknown (0 << 0)
+#define XINE_MRL_TYPE_dvd (1 << 0)
+#define XINE_MRL_TYPE_vcd (1 << 1)
+#define XINE_MRL_TYPE_net (1 << 2)
+#define XINE_MRL_TYPE_rtp (1 << 3)
+#define XINE_MRL_TYPE_stdin (1 << 4)
+#define XINE_MRL_TYPE_cda (1 << 5)
+#define XINE_MRL_TYPE_file (1 << 6)
+#define XINE_MRL_TYPE_file_fifo (1 << 7)
+#define XINE_MRL_TYPE_file_chardev (1 << 8)
+#define XINE_MRL_TYPE_file_directory (1 << 9)
+#define XINE_MRL_TYPE_file_blockdev (1 << 10)
+#define XINE_MRL_TYPE_file_normal (1 << 11)
+#define XINE_MRL_TYPE_file_symlink (1 << 12)
+#define XINE_MRL_TYPE_file_sock (1 << 13)
+#define XINE_MRL_TYPE_file_exec (1 << 14)
+#define XINE_MRL_TYPE_file_backup (1 << 15)
+#define XINE_MRL_TYPE_file_hidden (1 << 16)
+
+/* get a list of browsable input plugin ids */
+const char *const *xine_get_browsable_input_plugin_ids (xine_t *self) ;
+
+/*
+ * ask input plugin named <plugin_id> to return
+ * a list of available MRLs in domain/directory <start_mrl>.
+ *
+ * <start_mrl> may be NULL indicating the toplevel domain/dir
+ * returns <start_mrl> if <start_mrl> is a valid MRL, not a directory
+ * returns NULL if <start_mrl> is an invalid MRL, not even a directory.
+ */
+xine_mrl_t **xine_get_browse_mrls (xine_t *self,
+ const char *plugin_id,
+ const char *start_mrl,
+ int *num_mrls);
+
+/* get a list of plugins that support the autoplay feature */
+const char *const *xine_get_autoplay_input_plugin_ids (xine_t *self);
+
+/* get autoplay MRL list from input plugin named <plugin_id> */
+char **xine_get_autoplay_mrls (xine_t *self,
+ const char *plugin_id,
+ int *num_mrls);
+
+/* get a list of file extensions for file types supported by xine
+ * the list is separated by spaces
+ *
+ * the pointer returned can be free()ed when no longer used */
+char *xine_get_file_extensions (xine_t *self);
+
+/* get a list of mime types supported by xine
+ *
+ * the pointer returned can be free()ed when no longer used */
+char *xine_get_mime_types (xine_t *self);
+
+/* get the demuxer identifier that handles a given mime type
+ *
+ * the pointer returned can be free()ed when no longer used
+ * returns NULL if no demuxer is available to handle this. */
+char *xine_get_demux_for_mime_type (xine_t *self, const char *mime_type);
+
+/* get a description string for an input plugin */
+const char *xine_get_input_plugin_description (xine_t *self,
+ const char *plugin_id);
+
+/* get lists of available audio and video output plugins */
+const char *const *xine_list_audio_output_plugins (xine_t *self) ;
+const char *const *xine_list_video_output_plugins (xine_t *self) ;
+
+
+/*********************************************************************
+ * visual specific gui <-> xine engine communication *
+ *********************************************************************/
+
+/* talk to video output driver - old method */
+int xine_gui_send_vo_data (xine_stream_t *self,
+ int type, void *data);
+
+/* new (preferred) method to talk to video driver. */
+int xine_port_send_gui_data (xine_video_port_t *vo,
+ int type, void *data);
+
+typedef struct {
+
+ /* area of that drawable to be used by video */
+ int x,y,w,h;
+
+} x11_rectangle_t;
+
+/*
+ * this is the visual data struct any x11 gui
+ * must supply to the xine_open_video_driver call
+ * ("data" parameter)
+ */
+typedef struct {
+
+ /* some information about the display */
+ void *display; /* Display* */
+ int screen;
+
+ /* drawable to display the video in/on */
+ unsigned long d; /* Drawable */
+
+ void *user_data;
+
+ /*
+ * dest size callback
+ *
+ * this will be called by the video driver to find out
+ * how big the video output area size will be for a
+ * given video size. The ui should _not_ adjust it's
+ * video out area, just do some calculations and return
+ * the size. This will be called for every frame, ui
+ * implementation should be fast.
+ * dest_pixel_aspect should be set to the used display pixel aspect.
+ * NOTE: Semantics has changed: video_width and video_height
+ * are no longer pixel aspect corrected. Get the old semantics
+ * in the UI with
+ * *dest_pixel_aspect = display_pixel_aspect;
+ * if (video_pixel_aspect >= display_pixel_aspect)
+ * video_width = video_width * video_pixel_aspect / display_pixel_aspect + .5;
+ * else
+ * video_height = video_height * display_pixel_aspect / video_pixel_aspect + .5;
+ */
+ void (*dest_size_cb) (void *user_data,
+ int video_width, int video_height,
+ double video_pixel_aspect,
+ int *dest_width, int *dest_height,
+ double *dest_pixel_aspect);
+
+ /*
+ * frame output callback
+ *
+ * this will be called by the video driver for every frame
+ * it's about to draw. ui can adapt it's size if necessary
+ * here.
+ * note: the ui doesn't have to adjust itself to this
+ * size, this is just to be taken as a hint.
+ * ui must return the actual size of the video output
+ * area and the video output driver will do it's best
+ * to adjust the video frames to that size (while
+ * preserving aspect ratio and stuff).
+ * dest_x, dest_y: offset inside window
+ * dest_width, dest_height: available drawing space
+ * dest_pixel_aspect: display pixel aspect
+ * win_x, win_y: window absolute screen position
+ * NOTE: Semantics has changed: video_width and video_height
+ * are no longer pixel aspect corrected. Get the old semantics
+ * in the UI with
+ * *dest_pixel_aspect = display_pixel_aspect;
+ * if (video_pixel_aspect >= display_pixel_aspect)
+ * video_width = video_width * video_pixel_aspect / display_pixel_aspect + .5;
+ * else
+ * video_height = video_height * display_pixel_aspect / video_pixel_aspect + .5;
+ */
+ void (*frame_output_cb) (void *user_data,
+ int video_width, int video_height,
+ double video_pixel_aspect,
+ int *dest_x, int *dest_y,
+ int *dest_width, int *dest_height,
+ double *dest_pixel_aspect,
+ int *win_x, int *win_y);
+
+} x11_visual_t;
+
+/*
+ * this is the visual data struct any fb gui
+ * may supply to the xine_open_video_driver call
+ * ("data" parameter) to get frame_output_cd calls
+ */
+
+typedef struct {
+
+ void (*frame_output_cb) (void *user_data,
+ int video_width, int video_height,
+ double video_pixel_aspect,
+ int *dest_x, int *dest_y,
+ int *dest_width, int *dest_height,
+ double *dest_pixel_aspect,
+ int *win_x, int *win_y);
+
+ void *user_data;
+
+} fb_visual_t;
+
+/*
+ * "type" constants for xine_gui_send_vo_data (...)
+ */
+
+/* xevent *data */
+#define XINE_GUI_SEND_COMPLETION_EVENT 1
+
+/* Drawable data */
+#define XINE_GUI_SEND_DRAWABLE_CHANGED 2
+
+/* xevent *data */
+#define XINE_GUI_SEND_EXPOSE_EVENT 3
+
+/* x11_rectangle_t *data */
+#define XINE_GUI_SEND_TRANSLATE_GUI_TO_VIDEO 4
+
+/* int data */
+#define XINE_GUI_SEND_VIDEOWIN_VISIBLE 5
+
+/* *data contains chosen visual, select a new one or change it to NULL
+ * to indicate the visual to use or that no visual will work */
+/* XVisualInfo **data */
+#define XINE_GUI_SEND_SELECT_VISUAL 8
+
+
+/*********************************************************************
+ * xine health check stuff *
+ *********************************************************************/
+
+#define XINE_HEALTH_CHECK_OK 0
+#define XINE_HEALTH_CHECK_FAIL 1
+#define XINE_HEALTH_CHECK_UNSUPPORTED 2
+#define XINE_HEALTH_CHECK_NO_SUCH_CHECK 3
+
+#define CHECK_KERNEL 0
+#define CHECK_MTRR 1
+#define CHECK_CDROM 2
+#define CHECK_DVDROM 3
+#define CHECK_DMA 4
+#define CHECK_X 5
+#define CHECK_XV 6
+
+struct xine_health_check_s {
+ int status;
+ const char* cdrom_dev;
+ const char* dvd_dev;
+ char* msg;
+ char* title;
+ char* explanation;
+};
+
+typedef struct xine_health_check_s xine_health_check_t;
+xine_health_check_t* xine_health_check(xine_health_check_t*, int check_num);
+
+
+/*********************************************************************
+ * configuration system *
+ *********************************************************************/
+
+/*
+ * config entry data types
+ */
+
+#define XINE_CONFIG_TYPE_UNKNOWN 0
+#define XINE_CONFIG_TYPE_RANGE 1
+#define XINE_CONFIG_TYPE_STRING 2
+#define XINE_CONFIG_TYPE_ENUM 3
+#define XINE_CONFIG_TYPE_NUM 4
+#define XINE_CONFIG_TYPE_BOOL 5
+
+typedef struct xine_cfg_entry_s xine_cfg_entry_t;
+
+typedef void (*xine_config_cb_t) (void *user_data,
+ xine_cfg_entry_t *entry);
+struct xine_cfg_entry_s {
+ const char *key; /* unique id (example: gui.logo_mrl) */
+
+ int type;
+
+ /* type unknown */
+ char *unknown_value;
+
+ /* type string */
+ char *str_value;
+ char *str_default;
+ char *str_sticky;
+
+ /* common to range, enum, num, bool: */
+ int num_value;
+ int num_default;
+
+ /* type range specific: */
+ int range_min;
+ int range_max;
+
+ /* type enum specific: */
+ char **enum_values;
+
+ /* help info for the user */
+ const char *description;
+ const char *help;
+
+ /* user experience level */
+ int exp_level; /* 0 => beginner,
+ 10 => advanced user,
+ 20 => expert */
+
+ /* callback function and data for live changeable values */
+ xine_config_cb_t callback;
+ void *callback_data;
+
+};
+
+const char *xine_config_register_string (xine_t *self,
+ const char *key,
+ const char *def_value,
+ const char *description,
+ const char *help,
+ int exp_level,
+ xine_config_cb_t changed_cb,
+ void *cb_data);
+
+int xine_config_register_range (xine_t *self,
+ const char *key,
+ int def_value,
+ int min, int max,
+ const char *description,
+ const char *help,
+ int exp_level,
+ xine_config_cb_t changed_cb,
+ void *cb_data);
+
+int xine_config_register_enum (xine_t *self,
+ const char *key,
+ int def_value,
+ char **values,
+ const char *description,
+ const char *help,
+ int exp_level,
+ xine_config_cb_t changed_cb,
+ void *cb_data);
+
+int xine_config_register_num (xine_t *self,
+ const char *key,
+ int def_value,
+ const char *description,
+ const char *help,
+ int exp_level,
+ xine_config_cb_t changed_cb,
+ void *cb_data);
+
+int xine_config_register_bool (xine_t *self,
+ const char *key,
+ int def_value,
+ const char *description,
+ const char *help,
+ int exp_level,
+ xine_config_cb_t changed_cb,
+ void *cb_data);
+
+/*
+ * the following functions will copy data from the internal xine_config
+ * data database to the xine_cfg_entry_t *entry you provide
+ *
+ * they return 1 on success, 0 on failure
+ */
+
+/* get first config item */
+int xine_config_get_first_entry (xine_t *self, xine_cfg_entry_t *entry);
+
+/* get next config item (iterate through the items) */
+int xine_config_get_next_entry (xine_t *self, xine_cfg_entry_t *entry);
+
+/* search for a config entry by key */
+int xine_config_lookup_entry (xine_t *self, const char *key,
+ xine_cfg_entry_t *entry);
+
+/*
+ * update a config entry (which was returned from lookup_entry() )
+ *
+ * xine will make a deep copy of the data in the entry into it's internal
+ * config database.
+ */
+void xine_config_update_entry (xine_t *self,
+ const xine_cfg_entry_t *entry);
+
+/*
+ * load/save config data from/to afile (e.g. $HOME/.xine/config)
+ */
+void xine_config_load (xine_t *self, const char *cfg_filename);
+void xine_config_save (xine_t *self, const char *cfg_filename);
+void xine_config_reset (xine_t *self);
+
+
+/*********************************************************************
+ * asynchroneous xine event mechanism *
+ *********************************************************************/
+
+/*
+ * to receive events you have to register an event queue with
+ * the xine engine (xine_event_new_queue, see below).
+ *
+ * then you can either
+ * 1) check for incoming events regularly (xine_event_get/wait),
+ * process them and free them using xine_event_free
+ * 2) use xine_event_create_listener_thread and specify a callback
+ * which will then be called for each event
+ *
+ * to send events to every module listening you don't need
+ * to register an event queue but simply call xine_event_send.
+ */
+
+/* event types */
+#define XINE_EVENT_UI_PLAYBACK_FINISHED 1 /* frontend can e.g. move on to next playlist entry */
+#define XINE_EVENT_UI_CHANNELS_CHANGED 2 /* inform ui that new channel info is available */
+#define XINE_EVENT_UI_SET_TITLE 3 /* request title display change in ui */
+#define XINE_EVENT_UI_MESSAGE 4 /* message (dialog) for the ui to display */
+#define XINE_EVENT_FRAME_FORMAT_CHANGE 5 /* e.g. aspect ratio change during dvd playback */
+#define XINE_EVENT_AUDIO_LEVEL 6 /* report current audio level (l/r) */
+#define XINE_EVENT_QUIT 7 /* last event sent when stream is disposed */
+#define XINE_EVENT_PROGRESS 8 /* index creation/network connections */
+#define XINE_EVENT_MRL_REFERENCE 9 /* demuxer->frontend: MRL reference(s) for the real stream */
+#define XINE_EVENT_UI_NUM_BUTTONS 10 /* number of buttons for interactive menus */
+
+/* input events coming from frontend */
+#define XINE_EVENT_INPUT_MOUSE_BUTTON 101
+#define XINE_EVENT_INPUT_MOUSE_MOVE 102
+#define XINE_EVENT_INPUT_MENU1 103
+#define XINE_EVENT_INPUT_MENU2 104
+#define XINE_EVENT_INPUT_MENU3 105
+#define XINE_EVENT_INPUT_MENU4 106
+#define XINE_EVENT_INPUT_MENU5 107
+#define XINE_EVENT_INPUT_MENU6 108
+#define XINE_EVENT_INPUT_MENU7 109
+#define XINE_EVENT_INPUT_UP 110
+#define XINE_EVENT_INPUT_DOWN 111
+#define XINE_EVENT_INPUT_LEFT 112
+#define XINE_EVENT_INPUT_RIGHT 113
+#define XINE_EVENT_INPUT_SELECT 114
+#define XINE_EVENT_INPUT_NEXT 115
+#define XINE_EVENT_INPUT_PREVIOUS 116
+#define XINE_EVENT_INPUT_ANGLE_NEXT 117
+#define XINE_EVENT_INPUT_ANGLE_PREVIOUS 118
+#define XINE_EVENT_INPUT_BUTTON_FORCE 119
+#define XINE_EVENT_INPUT_NUMBER_0 120
+#define XINE_EVENT_INPUT_NUMBER_1 121
+#define XINE_EVENT_INPUT_NUMBER_2 122
+#define XINE_EVENT_INPUT_NUMBER_3 123
+#define XINE_EVENT_INPUT_NUMBER_4 124
+#define XINE_EVENT_INPUT_NUMBER_5 125
+#define XINE_EVENT_INPUT_NUMBER_6 126
+#define XINE_EVENT_INPUT_NUMBER_7 127
+#define XINE_EVENT_INPUT_NUMBER_8 128
+#define XINE_EVENT_INPUT_NUMBER_9 129
+#define XINE_EVENT_INPUT_NUMBER_10_ADD 130
+
+/* specific event types */
+#define XINE_EVENT_SET_V4L2 200
+#define XINE_EVENT_PVR_SAVE 201
+#define XINE_EVENT_PVR_REPORT_NAME 202
+#define XINE_EVENT_PVR_REALTIME 203
+
+/*
+ * xine event struct
+ */
+typedef struct {
+ int type; /* event type (constants see above) */
+ xine_stream_t *stream; /* stream this event belongs to */
+
+ void *data; /* contents depending on type */
+ int data_length;
+
+ /* you do not have to provide this, it will be filled in by xine_event_send() */
+ struct timeval tv; /* timestamp of event creation */
+} xine_event_t;
+
+/*
+ * input event dynamic data
+ */
+typedef struct {
+ xine_event_t event;
+ uint8_t button; /* Generally 1 = left, 2 = mid, 3 = right */
+ uint16_t x,y; /* In Image space */
+} xine_input_data_t;
+
+/*
+ * UI event dynamic data - send information to/from UI.
+ */
+typedef struct {
+ int num_buttons;
+ int str_len;
+ char str[256]; /* might be longer */
+} xine_ui_data_t;
+
+/*
+ * Send messages to UI. used mostly to report errors.
+ */
+typedef struct {
+ /*
+ * old xine-ui versions expect xine_ui_data_t type.
+ * this struct is added for compatibility.
+ */
+ xine_ui_data_t compatibility;
+
+ /* See XINE_MSG_xxx for defined types. */
+ int type;
+
+ /* defined types are provided with a standard explanation.
+ * note: zero means no explanation.
+ */
+ int explanation; /* add to struct address to get a valid (char *) */
+
+ /* parameters are zero terminated strings */
+ int num_parameters;
+ int parameters; /* add to struct address to get a valid (char *) */
+
+ /* where messages are stored, will be longer
+ *
+ * this field begins with the message text itself (\0-terminated),
+ * followed by (optional) \0-terminated parameter strings
+ * the end marker is \0 \0
+ */
+ char messages[1];
+} xine_ui_message_data_t;
+
+
+/*
+ * notify frame format change
+ */
+typedef struct {
+ int width;
+ int height;
+ int aspect;
+} xine_format_change_data_t;
+
+/*
+ * audio level for left/right channel
+ */
+typedef struct {
+ int left;
+ int right; /* 0..255 */
+} xine_audio_level_data_t;
+
+/*
+ * index generation / buffering
+ */
+typedef struct {
+ const char *description; /* e.g. "connecting..." */
+ int percent;
+} xine_progress_data_t;
+
+/*
+ * mrl reference data is sent by demuxers when a reference stream is found.
+ * this stream just contains pointers (urls) to the real data, which are
+ * passed to frontend using this event type. (examples: .asx, .mov and .ram)
+ *
+ * ideally, frontends should add these mrls to a "hierarchical playlist".
+ * that is, instead of the original file, the ones provided here should be
+ * played instead. on pratice, just using a simple playlist should work.
+ *
+ * mrl references should be played in the same order they are received, just
+ * after the current stream finishes.
+ * alternative playlists may be provided and should be used in case of
+ * failure of the primary playlist.
+ */
+typedef struct {
+ int alternative; /* alternative playlist number, usually 0 */
+ char mrl[1]; /* might (will) be longer */
+} xine_mrl_reference_data_t;
+
+
+#ifdef XINE_ENABLE_EXPERIMENTAL_FEATURES
+
+/*
+ * configuration options for video4linux-like input plugins
+ */
+typedef struct {
+ /* input selection */
+ int input; /* select active input from card */
+ int channel; /* channel number */
+ int radio; /* ask for a radio channel */
+ uint32_t frequency; /* frequency divided by 62.5KHz or 62.5 Hz */
+ uint32_t transmission; /* The transmission standard. */
+
+ /* video parameters */
+ uint32_t framerate_numerator; /* framerate as numerator/denominator */
+ uint32_t framerate_denominator;
+ uint32_t framelines; /* Total lines per frame including blanking */
+ uint32_t colorstandard; /* One of the V4L2_COLOR_STD_* values */
+ uint32_t colorsubcarrier; /* The color subcarrier frequency */
+ int frame_width; /* scaled frame width */
+ int frame_height; /* scaled frame height */
+
+ /* used by pvr plugin */
+ int32_t session_id; /* -1 stops pvr recording */
+} xine_set_v4l2_data_t;
+
+/*
+ * ask pvr to save (ie. do not discard) the current session
+ * see comments on input_pvr.c to understand how it works.
+ */
+typedef struct {
+ /* mode values:
+ * -1 = do nothing, just set the name
+ * 0 = truncate current session and save from now on
+ * 1 = save from last sync point
+ * 2 = save everything on current session
+ */
+ int mode;
+ int id;
+ char name[256]; /* name for saving, might be longer */
+} xine_pvr_save_data_t;
+
+typedef struct {
+ /* mode values:
+ * 0 = non realtime
+ * 1 = realtime
+ */
+ int mode;
+} xine_pvr_realtime_t;
+
+#endif
+
+/*
+ * Defined message types for XINE_EVENT_UI_MESSAGE
+ * This is the mechanism to report async errors from engine.
+ *
+ * If frontend knows about the XINE_MSG_xxx type it may safely
+ * ignore the 'explanation' field and provide it's own custom
+ * dialog to the 'parameters'.
+ *
+ * right column specifies the usual parameters.
+ */
+
+#define XINE_MSG_NO_ERROR 0 /* (messages to UI) */
+#define XINE_MSG_GENERAL_WARNING 1 /* (warning message) */
+#define XINE_MSG_UNKNOWN_HOST 2 /* (host name) */
+#define XINE_MSG_UNKNOWN_DEVICE 3 /* (device name) */
+#define XINE_MSG_NETWORK_UNREACHABLE 4 /* none */
+#define XINE_MSG_CONNECTION_REFUSED 5 /* (host name) */
+#define XINE_MSG_FILE_NOT_FOUND 6 /* (file name or mrl) */
+#define XINE_MSG_READ_ERROR 7 /* (device/file/mrl) */
+#define XINE_MSG_LIBRARY_LOAD_ERROR 8 /* (library/decoder) */
+#define XINE_MSG_ENCRYPTED_SOURCE 9 /* none */
+
+/* opaque xine_event_queue_t */
+typedef struct xine_event_queue_s xine_event_queue_t;
+
+/*
+ * register a new event queue
+ *
+ * you have to receive messages from this queue regularly
+ *
+ * use xine_event_dispose_queue to unregister and free the queue
+ */
+xine_event_queue_t *xine_event_new_queue (xine_stream_t *stream);
+void xine_event_dispose_queue (xine_event_queue_t *queue);
+
+/*
+ * receive events (poll)
+ *
+ * use xine_event_free on the events received from these calls
+ * when they're no longer needed
+ */
+xine_event_t *xine_event_get (xine_event_queue_t *queue);
+xine_event_t *xine_event_wait (xine_event_queue_t *queue);
+void xine_event_free (xine_event_t *event);
+
+/*
+ * receive events (callback)
+ *
+ * a thread is created which will receive all events from
+ * the specified queue, call your callback on each of them
+ * and will then free the event when your callback returns
+ *
+ */
+typedef void (*xine_event_listener_cb_t) (void *user_data,
+ const xine_event_t *event);
+void xine_event_create_listener_thread (xine_event_queue_t *queue,
+ xine_event_listener_cb_t callback,
+ void *user_data);
+
+/*
+ * send an event to all queues
+ *
+ * the event will be copied so you can free or reuse
+ * *event as soon as xine_event_send returns.
+ */
+void xine_event_send (xine_stream_t *stream, const xine_event_t *event);
+
+
+/*********************************************************************
+ * OSD (on screen display) *
+ *********************************************************************/
+
+#define XINE_TEXT_PALETTE_SIZE 11
+
+#define XINE_OSD_TEXT1 (0 * XINE_TEXT_PALETTE_SIZE)
+#define XINE_OSD_TEXT2 (1 * XINE_TEXT_PALETTE_SIZE)
+#define XINE_OSD_TEXT3 (2 * XINE_TEXT_PALETTE_SIZE)
+#define XINE_OSD_TEXT4 (3 * XINE_TEXT_PALETTE_SIZE)
+#define XINE_OSD_TEXT5 (4 * XINE_TEXT_PALETTE_SIZE)
+#define XINE_OSD_TEXT6 (5 * XINE_TEXT_PALETTE_SIZE)
+#define XINE_OSD_TEXT7 (6 * XINE_TEXT_PALETTE_SIZE)
+#define XINE_OSD_TEXT8 (7 * XINE_TEXT_PALETTE_SIZE)
+#define XINE_OSD_TEXT9 (8 * XINE_TEXT_PALETTE_SIZE)
+#define XINE_OSD_TEXT10 (9 * XINE_TEXT_PALETTE_SIZE)
+
+/* white text, black border, transparent background */
+#define XINE_TEXTPALETTE_WHITE_BLACK_TRANSPARENT 0
+/* white text, noborder, transparent background */
+#define XINE_TEXTPALETTE_WHITE_NONE_TRANSPARENT 1
+/* white text, no border, translucid background */
+#define XINE_TEXTPALETTE_WHITE_NONE_TRANSLUCID 2
+/* yellow text, black border, transparent background */
+#define XINE_TEXTPALETTE_YELLOW_BLACK_TRANSPARENT 3
+
+typedef struct xine_osd_s xine_osd_t;
+
+xine_osd_t *xine_osd_new (xine_stream_t *self, int x, int y,
+ int width, int height);
+void xine_osd_draw_point (xine_osd_t *self, int x, int y, int color);
+
+void xine_osd_draw_line (xine_osd_t *self, int x1, int y1,
+ int x2, int y2, int color);
+void xine_osd_draw_rect (xine_osd_t *self, int x1, int y1,
+ int x2, int y2,
+ int color, int filled );
+/* for freetype2 fonts x1 and y1 specifies the beginning of the baseline,
+ for xine fonts x1 and y1 specifies the upper left corner of the text
+ to be rendered */
+void xine_osd_draw_text (xine_osd_t *self, int x1, int y1,
+ const char *text, int color_base);
+void xine_osd_draw_bitmap (xine_osd_t *self, uint8_t *bitmap,
+ int x1, int y1, int width, int height,
+ uint8_t *palette_map);
+/* for freetype2 fonts the height is taken from _baseline_ to top */
+void xine_osd_get_text_size (xine_osd_t *self, const char *text,
+ int *width, int *height);
+/* with freetype2 support compiled in, you can also specify a font file
+ as 'fontname' here */
+void xine_osd_set_font (xine_osd_t *self, const char *fontname,
+ int size);
+/* set position were overlay will be blended */
+void xine_osd_set_position (xine_osd_t *self, int x, int y);
+void xine_osd_show (xine_osd_t *self, int64_t vpts);
+void xine_osd_hide (xine_osd_t *self, int64_t vpts);
+/* empty drawing area */
+void xine_osd_clear (xine_osd_t *self);
+/*
+ * close osd rendering engine
+ * loaded fonts are unloaded
+ * osd objects are closed
+ */
+void xine_osd_free (xine_osd_t *self);
+void xine_osd_set_palette (xine_osd_t *self,
+ const uint32_t *const color,
+ const uint8_t *const trans );
+/*
+ * set on existing text palette
+ * (-1 to set used specified palette)
+ *
+ * color_base specifies the first color index to use for this text
+ * palette. The OSD palette is then modified starting at this
+ * color index, up to the size of the text palette.
+ *
+ * Use OSD_TEXT1, OSD_TEXT2, ... for some preassigned color indices.
+ */
+void xine_osd_set_text_palette (xine_osd_t *self,
+ int palette_number,
+ int color_base );
+/* get palette (color and transparency) */
+void xine_osd_get_palette (xine_osd_t *self, uint32_t *color,
+ uint8_t *trans);
+
+
+/*********************************************************************
+ * TV-mode API, to make it possible to use nvtvd to view movies *
+ *********************************************************************/
+
+/* connect to nvtvd server and save current TV and X settings */
+void xine_tvmode_init (xine_t *self);
+
+/* try to change TV state if enabled
+ * type select 'regular' (0) or 'TV' (1) state
+ * width frame width the mode should match best or 0 if unknown
+ * height frame height the mode should match best or 0 if unknown
+ * fps frame rate the mode should match best or 0 if unknown
+ * returns: finally selected state
+ */
+int xine_tvmode_switch (xine_t *self, int type, int width, int height, double fps);
+
+/* adapt (maximum) output size to visible area if necessary and return pixel
+ * aspect and real frame rate if available
+ */
+void xine_tvmode_size (xine_t *self, int *width, int *height,
+ double *pixelratio, double *fps);
+
+/* restore old TV and X settings and close nvtvd connection */
+void xine_tvmode_exit (xine_t *self);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/win32/include/xine/xineutils.h b/win32/include/xine/xineutils.h new file mode 100644 index 000000000..33696e718 --- /dev/null +++ b/win32/include/xine/xineutils.h @@ -0,0 +1,957 @@ +/*
+ * Copyright (C) 2000-2002 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: xineutils.h,v 1.1 2003/04/20 16:42:10 guenter Exp $
+ *
+ */
+#ifndef XINEUTILS_H
+#define XINEUTILS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <inttypes.h>
+#include <pthread.h>
+#include "attributes.h"
+#include "compat.h"
+#include "xmlparser.h"
+#include "xine_buffer.h"
+#include "configfile.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#if defined(__SUNPRO_C) || !defined(XINE_COMPILE)
+#define inline
+#endif
+
+ /*
+ * debugable mutexes
+ */
+
+ typedef struct {
+ pthread_mutex_t mutex;
+ char id[80];
+ char *locked_by;
+ } xine_mutex_t;
+
+ int xine_mutex_init (xine_mutex_t *mutex, const pthread_mutexattr_t *mutexattr,
+ char *id);
+
+ int xine_mutex_lock (xine_mutex_t *mutex, char *who);
+ int xine_mutex_unlock (xine_mutex_t *mutex, char *who);
+ int xine_mutex_destroy (xine_mutex_t *mutex);
+
+
+
+ /* CPU Acceleration */
+
+/*
+ * The type of an value that fits in an MMX register (note that long
+ * long constant values MUST be suffixed by LL and unsigned long long
+ * values by ULL, lest they be truncated by the compiler)
+ */
+
+/* generic accelerations */
+#define MM_ACCEL_MLIB 0x00000001
+
+/* x86 accelerations */
+#define MM_ACCEL_X86_MMX 0x80000000
+#define MM_ACCEL_X86_3DNOW 0x40000000
+#define MM_ACCEL_X86_MMXEXT 0x20000000
+#define MM_ACCEL_X86_SSE 0x10000000
+#define MM_ACCEL_X86_SSE2 0x08000000
+/* powerpc accelerations */
+#define MM_ACCEL_PPC_ALTIVEC 0x04000000
+/* x86 compat defines */
+#define MM_MMX MM_ACCEL_X86_MMX
+#define MM_3DNOW MM_ACCEL_X86_3DNOW
+#define MM_MMXEXT MM_ACCEL_X86_MMXEXT
+#define MM_SSE MM_ACCEL_X86_SSE
+#define MM_SSE2 MM_ACCEL_X86_SSE2
+
+uint32_t xine_mm_accel (void);
+/* uint32_t xine_mm_support (void) ; */
+
+#ifdef ARCH_X86
+
+typedef union {
+#ifdef _MSC_VER
+ int64_t q; /* Quadword (64-bit) value */
+ uint64_t uq; /* Unsigned Quadword */
+#else
+ long long q; /* Quadword (64-bit) value */
+ unsigned long long uq; /* Unsigned Quadword */
+#endif
+ int d[2]; /* 2 Doubleword (32-bit) values */
+ unsigned int ud[2]; /* 2 Unsigned Doubleword */
+ short w[4]; /* 4 Word (16-bit) values */
+ unsigned short uw[4]; /* 4 Unsigned Word */
+ char b[8]; /* 8 Byte (8-bit) values */
+ unsigned char ub[8]; /* 8 Unsigned Byte */
+ float s[2]; /* Single-precision (32-bit) value */
+} ATTR_ALIGN(8) mmx_t; /* On an 8-byte (64-bit) boundary */
+
+
+
+#define mmx_i2r(op,imm,reg) \
+ __asm__ __volatile__ (#op " %0, %%" #reg \
+ : /* nothing */ \
+ : "i" (imm) )
+
+#define mmx_m2r(op,mem,reg) \
+ __asm__ __volatile__ (#op " %0, %%" #reg \
+ : /* nothing */ \
+ : "m" (mem))
+
+#define mmx_r2m(op,reg,mem) \
+ __asm__ __volatile__ (#op " %%" #reg ", %0" \
+ : "=m" (mem) \
+ : /* nothing */ )
+
+#define mmx_r2r(op,regs,regd) \
+ __asm__ __volatile__ (#op " %" #regs ", %" #regd)
+
+
+#define emms() __asm__ __volatile__ ("emms")
+
+#define movd_m2r(var,reg) mmx_m2r (movd, var, reg)
+#define movd_r2m(reg,var) mmx_r2m (movd, reg, var)
+#define movd_r2r(regs,regd) mmx_r2r (movd, regs, regd)
+
+#define movq_m2r(var,reg) mmx_m2r (movq, var, reg)
+#define movq_r2m(reg,var) mmx_r2m (movq, reg, var)
+#define movq_r2r(regs,regd) mmx_r2r (movq, regs, regd)
+
+#define packssdw_m2r(var,reg) mmx_m2r (packssdw, var, reg)
+#define packssdw_r2r(regs,regd) mmx_r2r (packssdw, regs, regd)
+#define packsswb_m2r(var,reg) mmx_m2r (packsswb, var, reg)
+#define packsswb_r2r(regs,regd) mmx_r2r (packsswb, regs, regd)
+
+#define packuswb_m2r(var,reg) mmx_m2r (packuswb, var, reg)
+#define packuswb_r2r(regs,regd) mmx_r2r (packuswb, regs, regd)
+
+#define paddb_m2r(var,reg) mmx_m2r (paddb, var, reg)
+#define paddb_r2r(regs,regd) mmx_r2r (paddb, regs, regd)
+#define paddd_m2r(var,reg) mmx_m2r (paddd, var, reg)
+#define paddd_r2r(regs,regd) mmx_r2r (paddd, regs, regd)
+#define paddw_m2r(var,reg) mmx_m2r (paddw, var, reg)
+#define paddw_r2r(regs,regd) mmx_r2r (paddw, regs, regd)
+
+#define paddsb_m2r(var,reg) mmx_m2r (paddsb, var, reg)
+#define paddsb_r2r(regs,regd) mmx_r2r (paddsb, regs, regd)
+#define paddsw_m2r(var,reg) mmx_m2r (paddsw, var, reg)
+#define paddsw_r2r(regs,regd) mmx_r2r (paddsw, regs, regd)
+
+#define paddusb_m2r(var,reg) mmx_m2r (paddusb, var, reg)
+#define paddusb_r2r(regs,regd) mmx_r2r (paddusb, regs, regd)
+#define paddusw_m2r(var,reg) mmx_m2r (paddusw, var, reg)
+#define paddusw_r2r(regs,regd) mmx_r2r (paddusw, regs, regd)
+
+#define pand_m2r(var,reg) mmx_m2r (pand, var, reg)
+#define pand_r2r(regs,regd) mmx_r2r (pand, regs, regd)
+
+#define pandn_m2r(var,reg) mmx_m2r (pandn, var, reg)
+#define pandn_r2r(regs,regd) mmx_r2r (pandn, regs, regd)
+
+#define pcmpeqb_m2r(var,reg) mmx_m2r (pcmpeqb, var, reg)
+#define pcmpeqb_r2r(regs,regd) mmx_r2r (pcmpeqb, regs, regd)
+#define pcmpeqd_m2r(var,reg) mmx_m2r (pcmpeqd, var, reg)
+#define pcmpeqd_r2r(regs,regd) mmx_r2r (pcmpeqd, regs, regd)
+#define pcmpeqw_m2r(var,reg) mmx_m2r (pcmpeqw, var, reg)
+#define pcmpeqw_r2r(regs,regd) mmx_r2r (pcmpeqw, regs, regd)
+
+#define pcmpgtb_m2r(var,reg) mmx_m2r (pcmpgtb, var, reg)
+#define pcmpgtb_r2r(regs,regd) mmx_r2r (pcmpgtb, regs, regd)
+#define pcmpgtd_m2r(var,reg) mmx_m2r (pcmpgtd, var, reg)
+#define pcmpgtd_r2r(regs,regd) mmx_r2r (pcmpgtd, regs, regd)
+#define pcmpgtw_m2r(var,reg) mmx_m2r (pcmpgtw, var, reg)
+#define pcmpgtw_r2r(regs,regd) mmx_r2r (pcmpgtw, regs, regd)
+
+#define pmaddwd_m2r(var,reg) mmx_m2r (pmaddwd, var, reg)
+#define pmaddwd_r2r(regs,regd) mmx_r2r (pmaddwd, regs, regd)
+
+#define pmulhw_m2r(var,reg) mmx_m2r (pmulhw, var, reg)
+#define pmulhw_r2r(regs,regd) mmx_r2r (pmulhw, regs, regd)
+
+#define pmullw_m2r(var,reg) mmx_m2r (pmullw, var, reg)
+#define pmullw_r2r(regs,regd) mmx_r2r (pmullw, regs, regd)
+
+#define por_m2r(var,reg) mmx_m2r (por, var, reg)
+#define por_r2r(regs,regd) mmx_r2r (por, regs, regd)
+
+#define pslld_i2r(imm,reg) mmx_i2r (pslld, imm, reg)
+#define pslld_m2r(var,reg) mmx_m2r (pslld, var, reg)
+#define pslld_r2r(regs,regd) mmx_r2r (pslld, regs, regd)
+#define psllq_i2r(imm,reg) mmx_i2r (psllq, imm, reg)
+#define psllq_m2r(var,reg) mmx_m2r (psllq, var, reg)
+#define psllq_r2r(regs,regd) mmx_r2r (psllq, regs, regd)
+#define psllw_i2r(imm,reg) mmx_i2r (psllw, imm, reg)
+#define psllw_m2r(var,reg) mmx_m2r (psllw, var, reg)
+#define psllw_r2r(regs,regd) mmx_r2r (psllw, regs, regd)
+
+#define psrad_i2r(imm,reg) mmx_i2r (psrad, imm, reg)
+#define psrad_m2r(var,reg) mmx_m2r (psrad, var, reg)
+#define psrad_r2r(regs,regd) mmx_r2r (psrad, regs, regd)
+#define psraw_i2r(imm,reg) mmx_i2r (psraw, imm, reg)
+#define psraw_m2r(var,reg) mmx_m2r (psraw, var, reg)
+#define psraw_r2r(regs,regd) mmx_r2r (psraw, regs, regd)
+
+#define psrld_i2r(imm,reg) mmx_i2r (psrld, imm, reg)
+#define psrld_m2r(var,reg) mmx_m2r (psrld, var, reg)
+#define psrld_r2r(regs,regd) mmx_r2r (psrld, regs, regd)
+#define psrlq_i2r(imm,reg) mmx_i2r (psrlq, imm, reg)
+#define psrlq_m2r(var,reg) mmx_m2r (psrlq, var, reg)
+#define psrlq_r2r(regs,regd) mmx_r2r (psrlq, regs, regd)
+#define psrlw_i2r(imm,reg) mmx_i2r (psrlw, imm, reg)
+#define psrlw_m2r(var,reg) mmx_m2r (psrlw, var, reg)
+#define psrlw_r2r(regs,regd) mmx_r2r (psrlw, regs, regd)
+
+#define psubb_m2r(var,reg) mmx_m2r (psubb, var, reg)
+#define psubb_r2r(regs,regd) mmx_r2r (psubb, regs, regd)
+#define psubd_m2r(var,reg) mmx_m2r (psubd, var, reg)
+#define psubd_r2r(regs,regd) mmx_r2r (psubd, regs, regd)
+#define psubw_m2r(var,reg) mmx_m2r (psubw, var, reg)
+#define psubw_r2r(regs,regd) mmx_r2r (psubw, regs, regd)
+
+#define psubsb_m2r(var,reg) mmx_m2r (psubsb, var, reg)
+#define psubsb_r2r(regs,regd) mmx_r2r (psubsb, regs, regd)
+#define psubsw_m2r(var,reg) mmx_m2r (psubsw, var, reg)
+#define psubsw_r2r(regs,regd) mmx_r2r (psubsw, regs, regd)
+
+#define psubusb_m2r(var,reg) mmx_m2r (psubusb, var, reg)
+#define psubusb_r2r(regs,regd) mmx_r2r (psubusb, regs, regd)
+#define psubusw_m2r(var,reg) mmx_m2r (psubusw, var, reg)
+#define psubusw_r2r(regs,regd) mmx_r2r (psubusw, regs, regd)
+
+#define punpckhbw_m2r(var,reg) mmx_m2r (punpckhbw, var, reg)
+#define punpckhbw_r2r(regs,regd) mmx_r2r (punpckhbw, regs, regd)
+#define punpckhdq_m2r(var,reg) mmx_m2r (punpckhdq, var, reg)
+#define punpckhdq_r2r(regs,regd) mmx_r2r (punpckhdq, regs, regd)
+#define punpckhwd_m2r(var,reg) mmx_m2r (punpckhwd, var, reg)
+#define punpckhwd_r2r(regs,regd) mmx_r2r (punpckhwd, regs, regd)
+
+#define punpcklbw_m2r(var,reg) mmx_m2r (punpcklbw, var, reg)
+#define punpcklbw_r2r(regs,regd) mmx_r2r (punpcklbw, regs, regd)
+#define punpckldq_m2r(var,reg) mmx_m2r (punpckldq, var, reg)
+#define punpckldq_r2r(regs,regd) mmx_r2r (punpckldq, regs, regd)
+#define punpcklwd_m2r(var,reg) mmx_m2r (punpcklwd, var, reg)
+#define punpcklwd_r2r(regs,regd) mmx_r2r (punpcklwd, regs, regd)
+
+#define pxor_m2r(var,reg) mmx_m2r (pxor, var, reg)
+#define pxor_r2r(regs,regd) mmx_r2r (pxor, regs, regd)
+
+
+/* 3DNOW extensions */
+
+#define pavgusb_m2r(var,reg) mmx_m2r (pavgusb, var, reg)
+#define pavgusb_r2r(regs,regd) mmx_r2r (pavgusb, regs, regd)
+
+
+/* AMD MMX extensions - also available in intel SSE */
+
+
+#define mmx_m2ri(op,mem,reg,imm) \
+ __asm__ __volatile__ (#op " %1, %0, %%" #reg \
+ : /* nothing */ \
+ : "X" (mem), "X" (imm))
+#define mmx_r2ri(op,regs,regd,imm) \
+ __asm__ __volatile__ (#op " %0, %%" #regs ", %%" #regd \
+ : /* nothing */ \
+ : "X" (imm) )
+
+#define mmx_fetch(mem,hint) \
+ __asm__ __volatile__ ("prefetch" #hint " %0" \
+ : /* nothing */ \
+ : "X" (mem))
+
+
+#define maskmovq(regs,maskreg) mmx_r2ri (maskmovq, regs, maskreg)
+
+#define movntq_r2m(mmreg,var) mmx_r2m (movntq, mmreg, var)
+
+#define pavgb_m2r(var,reg) mmx_m2r (pavgb, var, reg)
+#define pavgb_r2r(regs,regd) mmx_r2r (pavgb, regs, regd)
+#define pavgw_m2r(var,reg) mmx_m2r (pavgw, var, reg)
+#define pavgw_r2r(regs,regd) mmx_r2r (pavgw, regs, regd)
+
+#define pextrw_r2r(mmreg,reg,imm) mmx_r2ri (pextrw, mmreg, reg, imm)
+
+#define pinsrw_r2r(reg,mmreg,imm) mmx_r2ri (pinsrw, reg, mmreg, imm)
+
+#define pmaxsw_m2r(var,reg) mmx_m2r (pmaxsw, var, reg)
+#define pmaxsw_r2r(regs,regd) mmx_r2r (pmaxsw, regs, regd)
+
+#define pmaxub_m2r(var,reg) mmx_m2r (pmaxub, var, reg)
+#define pmaxub_r2r(regs,regd) mmx_r2r (pmaxub, regs, regd)
+
+#define pminsw_m2r(var,reg) mmx_m2r (pminsw, var, reg)
+#define pminsw_r2r(regs,regd) mmx_r2r (pminsw, regs, regd)
+
+#define pminub_m2r(var,reg) mmx_m2r (pminub, var, reg)
+#define pminub_r2r(regs,regd) mmx_r2r (pminub, regs, regd)
+
+#define pmovmskb(mmreg,reg) \
+ __asm__ __volatile__ ("movmskps %" #mmreg ", %" #reg)
+
+#define pmulhuw_m2r(var,reg) mmx_m2r (pmulhuw, var, reg)
+#define pmulhuw_r2r(regs,regd) mmx_r2r (pmulhuw, regs, regd)
+
+#define prefetcht0(mem) mmx_fetch (mem, t0)
+#define prefetcht1(mem) mmx_fetch (mem, t1)
+#define prefetcht2(mem) mmx_fetch (mem, t2)
+#define prefetchnta(mem) mmx_fetch (mem, nta)
+
+#define psadbw_m2r(var,reg) mmx_m2r (psadbw, var, reg)
+#define psadbw_r2r(regs,regd) mmx_r2r (psadbw, regs, regd)
+
+#define pshufw_m2r(var,reg,imm) mmx_m2ri(pshufw, var, reg, imm)
+#define pshufw_r2r(regs,regd,imm) mmx_r2ri(pshufw, regs, regd, imm)
+
+#define sfence() __asm__ __volatile__ ("sfence\n\t")
+
+typedef union {
+ float sf[4]; /* Single-precision (32-bit) value */
+} ATTR_ALIGN(16) sse_t; /* On a 16 byte (128-bit) boundary */
+
+
+#define sse_i2r(op, imm, reg) \
+ __asm__ __volatile__ (#op " %0, %%" #reg \
+ : /* nothing */ \
+ : "X" (imm) )
+
+#define sse_m2r(op, mem, reg) \
+ __asm__ __volatile__ (#op " %0, %%" #reg \
+ : /* nothing */ \
+ : "X" (mem))
+
+#define sse_r2m(op, reg, mem) \
+ __asm__ __volatile__ (#op " %%" #reg ", %0" \
+ : "=X" (mem) \
+ : /* nothing */ )
+
+#define sse_r2r(op, regs, regd) \
+ __asm__ __volatile__ (#op " %" #regs ", %" #regd)
+
+#define sse_r2ri(op, regs, regd, imm) \
+ __asm__ __volatile__ (#op " %0, %%" #regs ", %%" #regd \
+ : /* nothing */ \
+ : "X" (imm) )
+
+#define sse_m2ri(op, mem, reg, subop) \
+ __asm__ __volatile__ (#op " %0, %%" #reg ", " #subop \
+ : /* nothing */ \
+ : "X" (mem))
+
+
+#define movaps_m2r(var, reg) sse_m2r(movaps, var, reg)
+#define movaps_r2m(reg, var) sse_r2m(movaps, reg, var)
+#define movaps_r2r(regs, regd) sse_r2r(movaps, regs, regd)
+
+#define movntps_r2m(xmmreg, var) sse_r2m(movntps, xmmreg, var)
+
+#define movups_m2r(var, reg) sse_m2r(movups, var, reg)
+#define movups_r2m(reg, var) sse_r2m(movups, reg, var)
+#define movups_r2r(regs, regd) sse_r2r(movups, regs, regd)
+
+#define movhlps_r2r(regs, regd) sse_r2r(movhlps, regs, regd)
+
+#define movlhps_r2r(regs, regd) sse_r2r(movlhps, regs, regd)
+
+#define movhps_m2r(var, reg) sse_m2r(movhps, var, reg)
+#define movhps_r2m(reg, var) sse_r2m(movhps, reg, var)
+
+#define movlps_m2r(var, reg) sse_m2r(movlps, var, reg)
+#define movlps_r2m(reg, var) sse_r2m(movlps, reg, var)
+
+#define movss_m2r(var, reg) sse_m2r(movss, var, reg)
+#define movss_r2m(reg, var) sse_r2m(movss, reg, var)
+#define movss_r2r(regs, regd) sse_r2r(movss, regs, regd)
+
+#define shufps_m2r(var, reg, index) sse_m2ri(shufps, var, reg, index)
+#define shufps_r2r(regs, regd, index) sse_r2ri(shufps, regs, regd, index)
+
+#define cvtpi2ps_m2r(var, xmmreg) sse_m2r(cvtpi2ps, var, xmmreg)
+#define cvtpi2ps_r2r(mmreg, xmmreg) sse_r2r(cvtpi2ps, mmreg, xmmreg)
+
+#define cvtps2pi_m2r(var, mmreg) sse_m2r(cvtps2pi, var, mmreg)
+#define cvtps2pi_r2r(xmmreg, mmreg) sse_r2r(cvtps2pi, mmreg, xmmreg)
+
+#define cvttps2pi_m2r(var, mmreg) sse_m2r(cvttps2pi, var, mmreg)
+#define cvttps2pi_r2r(xmmreg, mmreg) sse_r2r(cvttps2pi, mmreg, xmmreg)
+
+#define cvtsi2ss_m2r(var, xmmreg) sse_m2r(cvtsi2ss, var, xmmreg)
+#define cvtsi2ss_r2r(reg, xmmreg) sse_r2r(cvtsi2ss, reg, xmmreg)
+
+#define cvtss2si_m2r(var, reg) sse_m2r(cvtss2si, var, reg)
+#define cvtss2si_r2r(xmmreg, reg) sse_r2r(cvtss2si, xmmreg, reg)
+
+#define cvttss2si_m2r(var, reg) sse_m2r(cvtss2si, var, reg)
+#define cvttss2si_r2r(xmmreg, reg) sse_r2r(cvtss2si, xmmreg, reg)
+
+#define movmskps(xmmreg, reg) \
+ __asm__ __volatile__ ("movmskps %" #xmmreg ", %" #reg)
+
+#define addps_m2r(var, reg) sse_m2r(addps, var, reg)
+#define addps_r2r(regs, regd) sse_r2r(addps, regs, regd)
+
+#define addss_m2r(var, reg) sse_m2r(addss, var, reg)
+#define addss_r2r(regs, regd) sse_r2r(addss, regs, regd)
+
+#define subps_m2r(var, reg) sse_m2r(subps, var, reg)
+#define subps_r2r(regs, regd) sse_r2r(subps, regs, regd)
+
+#define subss_m2r(var, reg) sse_m2r(subss, var, reg)
+#define subss_r2r(regs, regd) sse_r2r(subss, regs, regd)
+
+#define mulps_m2r(var, reg) sse_m2r(mulps, var, reg)
+#define mulps_r2r(regs, regd) sse_r2r(mulps, regs, regd)
+
+#define mulss_m2r(var, reg) sse_m2r(mulss, var, reg)
+#define mulss_r2r(regs, regd) sse_r2r(mulss, regs, regd)
+
+#define divps_m2r(var, reg) sse_m2r(divps, var, reg)
+#define divps_r2r(regs, regd) sse_r2r(divps, regs, regd)
+
+#define divss_m2r(var, reg) sse_m2r(divss, var, reg)
+#define divss_r2r(regs, regd) sse_r2r(divss, regs, regd)
+
+#define rcpps_m2r(var, reg) sse_m2r(rcpps, var, reg)
+#define rcpps_r2r(regs, regd) sse_r2r(rcpps, regs, regd)
+
+#define rcpss_m2r(var, reg) sse_m2r(rcpss, var, reg)
+#define rcpss_r2r(regs, regd) sse_r2r(rcpss, regs, regd)
+
+#define rsqrtps_m2r(var, reg) sse_m2r(rsqrtps, var, reg)
+#define rsqrtps_r2r(regs, regd) sse_r2r(rsqrtps, regs, regd)
+
+#define rsqrtss_m2r(var, reg) sse_m2r(rsqrtss, var, reg)
+#define rsqrtss_r2r(regs, regd) sse_r2r(rsqrtss, regs, regd)
+
+#define sqrtps_m2r(var, reg) sse_m2r(sqrtps, var, reg)
+#define sqrtps_r2r(regs, regd) sse_r2r(sqrtps, regs, regd)
+
+#define sqrtss_m2r(var, reg) sse_m2r(sqrtss, var, reg)
+#define sqrtss_r2r(regs, regd) sse_r2r(sqrtss, regs, regd)
+
+#define andps_m2r(var, reg) sse_m2r(andps, var, reg)
+#define andps_r2r(regs, regd) sse_r2r(andps, regs, regd)
+
+#define andnps_m2r(var, reg) sse_m2r(andnps, var, reg)
+#define andnps_r2r(regs, regd) sse_r2r(andnps, regs, regd)
+
+#define orps_m2r(var, reg) sse_m2r(orps, var, reg)
+#define orps_r2r(regs, regd) sse_r2r(orps, regs, regd)
+
+#define xorps_m2r(var, reg) sse_m2r(xorps, var, reg)
+#define xorps_r2r(regs, regd) sse_r2r(xorps, regs, regd)
+
+#define maxps_m2r(var, reg) sse_m2r(maxps, var, reg)
+#define maxps_r2r(regs, regd) sse_r2r(maxps, regs, regd)
+
+#define maxss_m2r(var, reg) sse_m2r(maxss, var, reg)
+#define maxss_r2r(regs, regd) sse_r2r(maxss, regs, regd)
+
+#define minps_m2r(var, reg) sse_m2r(minps, var, reg)
+#define minps_r2r(regs, regd) sse_r2r(minps, regs, regd)
+
+#define minss_m2r(var, reg) sse_m2r(minss, var, reg)
+#define minss_r2r(regs, regd) sse_r2r(minss, regs, regd)
+
+#define cmpps_m2r(var, reg, op) sse_m2ri(cmpps, var, reg, op)
+#define cmpps_r2r(regs, regd, op) sse_r2ri(cmpps, regs, regd, op)
+
+#define cmpeqps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 0)
+#define cmpeqps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 0)
+
+#define cmpltps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 1)
+#define cmpltps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 1)
+
+#define cmpleps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 2)
+#define cmpleps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 2)
+
+#define cmpunordps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 3)
+#define cmpunordps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 3)
+
+#define cmpneqps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 4)
+#define cmpneqps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 4)
+
+#define cmpnltps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 5)
+#define cmpnltps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 5)
+
+#define cmpnleps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 6)
+#define cmpnleps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 6)
+
+#define cmpordps_m2r(var, reg) sse_m2ri(cmpps, var, reg, 7)
+#define cmpordps_r2r(regs, regd) sse_r2ri(cmpps, regs, regd, 7)
+
+#define cmpss_m2r(var, reg, op) sse_m2ri(cmpss, var, reg, op)
+#define cmpss_r2r(regs, regd, op) sse_r2ri(cmpss, regs, regd, op)
+
+#define cmpeqss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 0)
+#define cmpeqss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 0)
+
+#define cmpltss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 1)
+#define cmpltss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 1)
+
+#define cmpless_m2r(var, reg) sse_m2ri(cmpss, var, reg, 2)
+#define cmpless_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 2)
+
+#define cmpunordss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 3)
+#define cmpunordss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 3)
+
+#define cmpneqss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 4)
+#define cmpneqss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 4)
+
+#define cmpnltss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 5)
+#define cmpnltss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 5)
+
+#define cmpnless_m2r(var, reg) sse_m2ri(cmpss, var, reg, 6)
+#define cmpnless_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 6)
+
+#define cmpordss_m2r(var, reg) sse_m2ri(cmpss, var, reg, 7)
+#define cmpordss_r2r(regs, regd) sse_r2ri(cmpss, regs, regd, 7)
+
+#define comiss_m2r(var, reg) sse_m2r(comiss, var, reg)
+#define comiss_r2r(regs, regd) sse_r2r(comiss, regs, regd)
+
+#define ucomiss_m2r(var, reg) sse_m2r(ucomiss, var, reg)
+#define ucomiss_r2r(regs, regd) sse_r2r(ucomiss, regs, regd)
+
+#define unpcklps_m2r(var, reg) sse_m2r(unpcklps, var, reg)
+#define unpcklps_r2r(regs, regd) sse_r2r(unpcklps, regs, regd)
+
+#define unpckhps_m2r(var, reg) sse_m2r(unpckhps, var, reg)
+#define unpckhps_r2r(regs, regd) sse_r2r(unpckhps, regs, regd)
+
+#define fxrstor(mem) \
+ __asm__ __volatile__ ("fxrstor %0" \
+ : /* nothing */ \
+ : "X" (mem))
+
+#define fxsave(mem) \
+ __asm__ __volatile__ ("fxsave %0" \
+ : /* nothing */ \
+ : "X" (mem))
+
+#define stmxcsr(mem) \
+ __asm__ __volatile__ ("stmxcsr %0" \
+ : /* nothing */ \
+ : "X" (mem))
+
+#define ldmxcsr(mem) \
+ __asm__ __volatile__ ("ldmxcsr %0" \
+ : /* nothing */ \
+ : "X" (mem))
+#endif /*ARCH_X86 */
+
+
+
+ /* Optimized/fast memcpy */
+
+/*
+ TODO : fix dll linkage problem for xine_fast_memcpy on win32
+
+ xine_fast_memcpy dll linkage is screwy here.
+ declairing as dllinport seems to fix the problem
+ but causes compiler warning with libxineutils
+*/
+#ifdef _MSC_VER
+void __declspec( dllimport ) *(* xine_fast_memcpy)(void *to, const void *from, size_t len);
+#else
+extern void *(* xine_fast_memcpy)(void *to, const void *from, size_t len);
+#endif
+
+#ifdef HAVE_XINE_INTERNAL_H
+/* Benchmark available memcpy methods */
+void xine_probe_fast_memcpy(config_values_t *config);
+#endif
+
+
+/*
+ * Debug stuff
+ */
+/*
+ * profiling (unworkable in non DEBUG isn't defined)
+ */
+void xine_profiler_init (void);
+int xine_profiler_allocate_slot (char *label);
+void xine_profiler_start_count (int id);
+void xine_profiler_stop_count (int id);
+void xine_profiler_print_results (void);
+
+/*
+ * Allocate and clean memory size_t 'size', then return the pointer
+ * to the allocated memory.
+ */
+void *xine_xmalloc(size_t size);
+
+/*
+ * Same as above, but memory is aligned to 'alignement'.
+ * **base is used to return pointer to un-aligned memory, use
+ * this to free the mem chunk
+ */
+void *xine_xmalloc_aligned(size_t alignment, size_t size, void **base);
+
+/*
+ * Get user home directory.
+ */
+const char *xine_get_homedir(void);
+
+/*
+ * Clean a string (remove spaces and '=' at the begin,
+ * and '\n', '\r' and spaces at the end.
+ */
+char *xine_chomp (char *str);
+
+/*
+ * A thread-safe usecond sleep
+ */
+void xine_usec_sleep(unsigned usec);
+
+
+ /*
+ * Some string functions
+ */
+
+
+void xine_strdupa(char *dest, char *src);
+#define xine_strdupa(d, s) do { \
+ (d) = NULL; \
+ if((s) != NULL) { \
+ (d) = (char *) alloca(strlen((s)) + 1); \
+ strcpy((d), (s)); \
+ } \
+ } while(0)
+
+/* Shamefully copied from glibc 2.2.3 */
+#ifdef HAVE_STRPBRK
+#define xine_strpbrk strpbrk
+#else
+static inline char *_x_strpbrk(const char *s, const char *accept) {
+
+ while(*s != '\0') {
+ const char *a = accept;
+ while(*a != '\0')
+ if(*a++ == *s)
+ return(char *) s;
+ ++s;
+ }
+
+ return NULL;
+}
+#define xine_strpbrk _x_strpbrk
+#endif
+
+#ifdef HAVE_STRSEP
+#define xine_strsep strsep
+#else
+static inline char *_x_strsep(char **stringp, const char *delim) {
+ char *begin, *end;
+
+ begin = *stringp;
+ if(begin == NULL)
+ return NULL;
+
+ if(delim[0] == '\0' || delim[1] == '\0') {
+ char ch = delim[0];
+
+ if(ch == '\0')
+ end = NULL;
+ else {
+ if(*begin == ch)
+ end = begin;
+ else if(*begin == '\0')
+ end = NULL;
+ else
+ end = strchr(begin + 1, ch);
+ }
+ }
+ else
+ end = xine_strpbrk(begin, delim);
+
+ if(end) {
+ *end++ = '\0';
+ *stringp = end;
+ }
+ else
+ *stringp = NULL;
+
+ return begin;
+}
+#define xine_strsep _x_strsep
+#endif
+
+
+#ifdef HAVE_SETENV
+#define xine_setenv setenv
+#else
+static inline void _x_setenv(const char *name, const char *val, int _xx)
+{
+ int len = strlen(name) + strlen(val) + 2;
+ char *env;
+
+ env = (char*)malloc(len);
+
+ if (env != NULL) {
+ strcpy(env, name);
+ strcat(env, "=");
+ strcat(env, val);
+ putenv(env);
+ }
+}
+#define xine_setenv _x_setenv
+#endif
+
+/*
+ * Color Conversion Utility Functions
+ * The following data structures and functions facilitate the conversion
+ * of RGB images to packed YUV (YUY2) images. There are also functions to
+ * convert from YUV9 -> YV12. All of the meaty details are written in
+ * color.c.
+ */
+
+typedef struct yuv_planes_s {
+
+ unsigned char *y;
+ unsigned char *u;
+ unsigned char *v;
+ unsigned int row_width; /* frame width */
+ unsigned int row_count; /* frame height */
+
+} yuv_planes_t;
+
+void init_yuv_conversion(void);
+void init_yuv_planes(yuv_planes_t *yuv_planes, int width, int height);
+void free_yuv_planes(yuv_planes_t *yuv_planes);
+
+extern void (*yuv444_to_yuy2)
+ (yuv_planes_t *yuv_planes, unsigned char *yuy2_map, int pitch);
+extern void (*yuv9_to_yv12)
+ (unsigned char *y_src, int y_src_pitch, unsigned char *y_dest, int y_dest_pitch,
+ unsigned char *u_src, int u_src_pitch, unsigned char *u_dest, int u_dest_pitch,
+ unsigned char *v_src, int v_src_pitch, unsigned char *v_dest, int v_dest_pitch,
+ int width, int height);
+extern void (*yuv411_to_yv12)
+ (unsigned char *y_src, int y_src_pitch, unsigned char *y_dest, int y_dest_pitch,
+ unsigned char *u_src, int u_src_pitch, unsigned char *u_dest, int u_dest_pitch,
+ unsigned char *v_src, int v_src_pitch, unsigned char *v_dest, int v_dest_pitch,
+ int width, int height);
+
+#define SCALEFACTOR 65536
+#define CENTERSAMPLE 128
+
+#define COMPUTE_Y(r, g, b) \
+ (unsigned char) \
+ ((y_r_table[r] + y_g_table[g] + y_b_table[b]) / SCALEFACTOR)
+#define COMPUTE_U(r, g, b) \
+ (unsigned char) \
+ ((u_r_table[r] + u_g_table[g] + u_b_table[b]) / SCALEFACTOR + CENTERSAMPLE)
+#define COMPUTE_V(r, g, b) \
+ (unsigned char) \
+ ((v_r_table[r] + v_g_table[g] + v_b_table[b]) / SCALEFACTOR + CENTERSAMPLE)
+
+#define UNPACK_BGR15(packed_pixel, r, g, b) \
+ b = (packed_pixel & 0x7C00) >> 7; \
+ g = (packed_pixel & 0x03E0) >> 2; \
+ r = (packed_pixel & 0x001F) << 3;
+
+#define UNPACK_BGR16(packed_pixel, r, g, b) \
+ b = (packed_pixel & 0xF800) >> 8; \
+ g = (packed_pixel & 0x07E0) >> 3; \
+ r = (packed_pixel & 0x001F) << 3;
+
+#define UNPACK_RGB15(packed_pixel, r, g, b) \
+ r = (packed_pixel & 0x7C00) >> 7; \
+ g = (packed_pixel & 0x03E0) >> 2; \
+ b = (packed_pixel & 0x001F) << 3;
+
+#define UNPACK_RGB16(packed_pixel, r, g, b) \
+ r = (packed_pixel & 0xF800) >> 8; \
+ g = (packed_pixel & 0x07E0) >> 3; \
+ b = (packed_pixel & 0x001F) << 3;
+
+extern int y_r_table[256];
+extern int y_g_table[256];
+extern int y_b_table[256];
+
+extern int u_r_table[256];
+extern int u_g_table[256];
+extern int u_b_table[256];
+
+extern int v_r_table[256];
+extern int v_g_table[256];
+extern int v_b_table[256];
+
+
+/* backtrace printout funtion for use in XINE_ASSERT() macro */
+void xine_print_trace(void);
+
+
+#ifdef DEBUG
+# define XINE_ABORT() \
+ abort();
+#else
+# define XINE_ABORT()
+ /* don't abort */
+#endif
+
+/**
+ * Provide assert like feature with better description of failure
+ * Thanks to Mark Thomas
+ */
+#if __GNUC__
+# define XINE_ASSERT(exp, desc, args...) \
+ do { \
+ if (!(exp)) { \
+ printf("%s:%s:%d: assertion `%s' failed. " desc "\n\n", \
+ __FILE__, __XINE_FUNCTION__, __LINE__, #exp, ##args); \
+ xine_print_trace(); \
+ XINE_ABORT(); \
+ } \
+ } while(0)
+#else /* not GNU C, assume we have a C99 compiler */
+
+#ifdef _MSC_VER
+/*
+ #define XINE_ASSERT(exp, desc) ((void)((exp) || \
+ (printf desc, _assert(#exp, __FILE__, __LINE__), 0)))
+
+*/
+# define XINE_ASSERT(exp, desc) \
+ do { \
+ if (!(exp)) { \
+ printf("%s:%s:%d: assertion `%s' failed. ", \
+ __FILE__, __XINE_FUNCTION__, __LINE__, #exp); \
+ printf(desc); \
+ printf("\n\n"); \
+ xine_print_trace(); \
+ XINE_ABORT(); \
+ } \
+ } while(0)
+#else
+# define XINE_ASSERT(exp, ...) \
+ do { \
+ if (!(exp)) { \
+ printf("%s:%s:%d: assertion `%s' failed. ", \
+ __FILE__, __XINE_FUNCTION__, __LINE__, #exp); \
+ printf(__VA_ARGS__); \
+ printf("\n\n"); \
+ xine_print_trace(); \
+ XINE_ABORT(); \
+ } \
+ } while(0)
+#endif /* _MSC_VER */
+
+#endif
+
+
+/******** double chained lists with builtin iterator *******/
+
+typedef struct xine_node_s {
+
+ struct xine_node_s *next, *prev;
+
+ void *content;
+
+ int priority;
+
+} xine_node_t;
+
+
+typedef struct {
+
+ xine_node_t *first, *last, *cur;
+
+} xine_list_t;
+
+
+
+xine_list_t *xine_list_new (void);
+
+
+/**
+ * dispose the whole list.
+ * note: disposes _only_ the list structure, content must be free()d elsewhere
+ */
+void xine_list_free(xine_list_t *l);
+
+
+/**
+ * returns: Boolean
+ */
+int xine_list_is_empty (xine_list_t *l);
+
+/**
+ * return content of first entry in list.
+ */
+void *xine_list_first_content (xine_list_t *l);
+
+/**
+ * return next content in list.
+ */
+void *xine_list_next_content (xine_list_t *l);
+
+/**
+ * Return last content of list.
+ */
+void *xine_list_last_content (xine_list_t *l);
+
+/**
+ * Return previous content of list.
+ */
+void *xine_list_prev_content (xine_list_t *l);
+
+/**
+ * Append content to list, sorted by decreasing priority.
+ */
+void xine_list_append_priority_content (xine_list_t *l, void *content, int priority);
+
+/**
+ * Append content to list.
+ */
+void xine_list_append_content (xine_list_t *l, void *content);
+
+/**
+ * Insert content in list.
+ */
+void xine_list_insert_content (xine_list_t *l, void *content);
+
+/**
+ * Remove current content in list.
+ * note: removes only the list entry; content must be free()d elsewhere.
+ */
+void xine_list_delete_current (xine_list_t *l);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
|