I tried compiling Xine last night albeit was the CVS from yesterday, so
maybe I need to grab the one from the 5th, but applied these patches and
when I compile it and try to do the install I get the following: This
is for XINE-LIB
make install-data-hook
make[4]: Entering directory
`/usr/local/src/xine.cvs/xine-lib/src/xine-engine'
chcon system_u:object_r:texrel_shlib_t /usr/lib/libxine.so
chcon: /usr/lib/libxine.so: Operation not supported
make[4]: *** [install-data-hook] Error 1
make[4]: Leaving directory
`/usr/local/src/xine.cvs/xine-lib/src/xine-engine'
make[3]: *** [install-data-am] Error 2
make[3]: Leaving directory
`/usr/local/src/xine.cvs/xine-lib/src/xine-engine'
make[2]: *** [install-am] Error 2
make[2]: Leaving directory
`/usr/local/src/xine.cvs/xine-lib/src/xine-engine'
make[1]: *** [install-recursive] Error 1
make[1]: Leaving directory `/usr/local/src/xine.cvs/xine-lib/src'
make: *** [install-recursive] Error 1
Anyone by chance know what I am missing, maybe in my configure or
whatnot? Thanks for any help.
Jaroslaw Swierczynski wrote:
>Here are patches from vdr-xine 0.7.6 that I modified to apply to
>xine-lib and xine-ui snapshots from January 5th. They work fine.
>
>Btw, why the Xine developers haven't applied those patches yet?
>
>--
>Jaroslaw Swierczynski <swiergot@xxxxxxxxx>
>www.archlinux.org | www.juvepoland.com
>
>
>------------------------------------------------------------------------
>
>diff -ruN xine-lib-1.1.1.orig/configure.ac xine-lib-1.1.1/configure.ac
>--- xine-lib-1.1.1.orig/configure.ac 2005-11-14 13:34:45.000000000 +0100
>+++ xine-lib-1.1.1/configure.ac 2006-01-02 19:49:17.000000000 +0100
>@@ -2298,6 +2298,7 @@
> src/video_out/vidix/drivers/Makefile
> src/xine-utils/Makefile
> src/xine-engine/Makefile
>+src/vdr/Makefile
> win32/Makefile
> win32/include/Makefile])
> AC_CONFIG_COMMANDS([default],[[chmod +x ./misc/SlackBuild ./misc/build_rpms.sh ./misc/relchk.sh]],[[]])
>@@ -2353,7 +2354,7 @@
> echo " - stdin_fifo - rtp"
> echo " - http - mms"
> echo " - pnm - rtsp"
>-echo " - dvb"
>+echo " - dvb - vdr"
> if test x"$external_dvdnav" = "xyes"; then
> echo " - dvd (external libs)"
> else
>@@ -2533,6 +2534,7 @@
> echo " - eq - eq2"
> echo " - boxblur - denoise3d"
> echo " - unsharp - tvtime"
>+echo " - vdr"
> echo " * SFX:"
> echo " - goom - oscope"
> echo " - fftscope - mosaico"
>diff -ruN xine-lib-1.1.1.orig/include/xine.h.in xine-lib-1.1.1/include/xine.h.in
>--- xine-lib-1.1.1.orig/include/xine.h.in 2005-11-15 12:41:03.000000000 +0100
>+++ xine-lib-1.1.1/include/xine.h.in 2006-01-02 19:49:55.000000000 +0100
>@@ -1528,6 +1528,9 @@
> /* some space for further keys */
> #define XINE_EVENT_VDR_SETVIDEOWINDOW 350
> #define XINE_EVENT_VDR_FRAMESIZECHANGED 351
>+#define XINE_EVENT_VDR_SELECTAUDIO 352
>+#define XINE_EVENT_VDR_TRICKSPEEDMODE 353
>+#define XINE_EVENT_VDR_PLUGINSTARTED 354
>
> /*
> * xine event struct
>diff -ruN xine-lib-1.1.1.orig/src/demuxers/demux_mpeg_pes.c xine-lib-1.1.1/src/demuxers/demux_mpeg_pes.c
>--- xine-lib-1.1.1.orig/src/demuxers/demux_mpeg_pes.c 2005-02-06 16:26:17.000000000 +0100
>+++ xine-lib-1.1.1/src/demuxers/demux_mpeg_pes.c 2006-01-02 19:53:31.000000000 +0100
>@@ -51,7 +51,7 @@
> #define NUM_PREVIEW_BUFFERS 250
> #define DISC_TRESHOLD 90000
>
>-#define WRAP_THRESHOLD 120000
>+#define WRAP_THRESHOLD 270000
> #define PTS_AUDIO 0
> #define PTS_VIDEO 1
>
>@@ -157,7 +157,7 @@
> }
>
> if( pts )
>- this->last_pts[video] = pts;
>+ this->last_pts[video] = this->last_pts[1-video] = pts;
> }
>
> static void demux_mpeg_pes_parse_pack (demux_mpeg_pes_t *this, int preview_mode) {
>diff -ruN xine-lib-1.1.1.orig/src/libmpeg2/decode.c xine-lib-1.1.1/src/libmpeg2/decode.c
>--- xine-lib-1.1.1.orig/src/libmpeg2/decode.c 2005-06-18 00:33:02.000000000 +0200
>+++ xine-lib-1.1.1/src/libmpeg2/decode.c 2006-01-02 19:59:24.000000000 +0100
>@@ -251,7 +251,7 @@
> }
>
> static inline int parse_chunk (mpeg2dec_t * mpeg2dec, int code,
>- uint8_t * buffer)
>+ uint8_t * buffer, int next_code)
> {
> picture_t * picture;
> int is_frame_done;
>@@ -408,6 +408,9 @@
> /* abort(); */
> break;
> }
>+
>+ picture->mpeg1 = (next_code != 0xb5);
>+
> if (mpeg2dec->force_aspect) picture->aspect_ratio_information = mpeg2dec->force_aspect;
>
> if (mpeg2dec->is_sequence_needed ) {
>@@ -593,6 +596,12 @@
> uint8_t * limit;
> uint8_t byte;
>
>+ if (mpeg2dec->code == 0xb7) {
>+ mpeg2dec->code = 0xb4;
>+ mpeg2dec->chunk_size = 0;
>+ return current;
>+ }
>+
> shift = mpeg2dec->shift;
> chunk_ptr = mpeg2dec->chunk_ptr;
> limit = current + (mpeg2dec->chunk_buffer + BUFFER_SIZE - chunk_ptr);
>@@ -644,12 +653,12 @@
> if (pts)
> mpeg2dec->pts = pts;
>
>- while (current != end) {
>+ while (current != end || mpeg2dec->code == 0xb7) {
> code = mpeg2dec->code;
> current = copy_chunk (mpeg2dec, current, end);
> if (current == NULL)
> break;
>- ret += parse_chunk (mpeg2dec, code, mpeg2dec->chunk_buffer);
>+ ret += parse_chunk (mpeg2dec, code, mpeg2dec->chunk_buffer, mpeg2dec->code);
> }
>
> libmpeg2_accel_frame_completion(&mpeg2dec->accel, mpeg2dec->frame_format,
>@@ -816,7 +825,7 @@
> void mpeg2_find_sequence_header (mpeg2dec_t * mpeg2dec,
> uint8_t * current, uint8_t * end){
>
>- uint8_t code;
>+ uint8_t code, next_code;
> picture_t *picture = mpeg2dec->picture;
>
> mpeg2dec->seek_mode = 1;
>@@ -826,6 +835,7 @@
> current = copy_chunk (mpeg2dec, current, end);
> if (current == NULL)
> return ;
>+ next_code = mpeg2dec->code;
>
> /* printf ("looking for sequence header... %02x\n", code); */
>
>@@ -836,6 +846,9 @@
> printf ("libmpeg2: bad sequence header\n");
> continue;
> }
>+
>+ picture->mpeg1 = (next_code != 0xb5);
>+
> if (mpeg2dec->force_aspect) picture->aspect_ratio_information = mpeg2dec->force_aspect;
>
> if (mpeg2dec->is_sequence_needed) {
>diff -ruN xine-lib-1.1.1.orig/src/Makefile.am xine-lib-1.1.1/src/Makefile.am
>--- xine-lib-1.1.1.orig/src/Makefile.am 2005-01-14 16:24:08.000000000 +0100
>+++ xine-lib-1.1.1/src/Makefile.am 2006-01-02 19:50:25.000000000 +0100
>@@ -29,5 +29,6 @@
> libreal \
> libfaad \
> libflac \
>- libmusepack \
>- post
>+ libmusepack \
>+ post \
>+ vdr
>diff -ruN xine-lib-1.1.1.orig/src/post/planar/expand.c xine-lib-1.1.1/src/post/planar/expand.c
>--- xine-lib-1.1.1.orig/src/post/planar/expand.c 2005-09-11 15:37:31.000000000 +0200
>+++ xine-lib-1.1.1/src/post/planar/expand.c 2006-01-02 20:06:11.000000000 +0100
>@@ -62,6 +62,7 @@
> typedef struct expand_parameters_s {
> int enable_automatic_shift;
> int overlay_y_offset;
>+ int centre_cut_out_mode;
> double aspect;
> } expand_parameters_t;
>
>@@ -70,6 +71,8 @@
> "enable automatic overlay shifting")
> PARAM_ITEM(POST_PARAM_TYPE_INT, overlay_y_offset, NULL, -500, 500, 0,
> "manually shift the overlay vertically")
>+PARAM_ITEM(POST_PARAM_TYPE_BOOL, centre_cut_out_mode, NULL, 0, 1, 0,
>+ "cut out centered 4:3 image contained in 16:9 frame")
> PARAM_ITEM(POST_PARAM_TYPE_DOUBLE, aspect, NULL, 1.0, 3.5, 0,
> "target aspect ratio")
> END_PARAM_DESCR(expand_param_descr)
>@@ -83,6 +86,8 @@
> int overlay_y_offset;
> double aspect;
> int top_bar_height;
>+ int centre_cut_out_mode;
>+ int cropping_active;
> } post_expand_t;
>
> /* plugin class functions */
>@@ -107,6 +112,8 @@
> uint32_t height, double ratio,
> int format, int flags);
>
>+static int expand_draw(vo_frame_t *frame, xine_stream_t *stream);
>+
> /* overlay manager intercept check */
> static int expand_intercept_ovl(post_video_port_t *port);
>
>@@ -151,12 +158,15 @@
>
> this->enable_automatic_shift = 0;
> this->overlay_y_offset = 0;
>+ this->centre_cut_out_mode = 0;
>+ this->cropping_active = 0;
> this->aspect = 4.0 / 3.0;
>
> port = _x_post_intercept_video_port(&this->post, video_target[0], &input, &output);
> port->new_port.get_frame = expand_get_frame;
> port->intercept_ovl = expand_intercept_ovl;
> port->new_manager->add_event = expand_overlay_add_event;
>+ port->new_frame->draw = expand_draw;
>
> input_param = &this->parameter_input;
> input_param->name = "parameters";
>@@ -211,6 +221,7 @@
>
> this->enable_automatic_shift = param->enable_automatic_shift;
> this->overlay_y_offset = param->overlay_y_offset;
>+ this->centre_cut_out_mode = param->centre_cut_out_mode;
> this->aspect = param->aspect;
> return 1;
> }
>@@ -222,6 +233,7 @@
>
> param->enable_automatic_shift = this->enable_automatic_shift;
> param->overlay_y_offset = this->overlay_y_offset;
>+ param->centre_cut_out_mode = this->centre_cut_out_mode;
> param->aspect = this->aspect;
> return 1;
> }
>@@ -322,6 +334,10 @@
>
> static int expand_intercept_ovl(post_video_port_t *port)
> {
>+ post_expand_t *this = (post_expand_t *)port->post;
>+
>+ if (this->centre_cut_out_mode && this->cropping_active) return 0;
>+
> /* we always intercept overlay manager */
> return 1;
> }
>@@ -350,3 +366,78 @@
>
> return port->original_manager->add_event(port->original_manager, event_gen);
> }
>+
>+static int is_pixel_black(vo_frame_t *frame, int x, int y)
>+{
>+ int Y = 0x00, Cr = 0x00, Cb = 0x00;
>+
>+ if (x < 0) x = 0;
>+ if (x >= frame->width) x = frame->width - 1;
>+ if (y < 0) y = 0;
>+ if (y >= frame->height) y = frame->height - 1;
>+
>+ switch (frame->format)
>+ {
>+ case XINE_IMGFMT_YV12:
>+ Y = *(frame->base[ 0 ] + frame->pitches[ 0 ] * y + x);
>+ Cr = *(frame->base[ 1 ] + frame->pitches[ 1 ] * y / 2 + x / 2);
>+ Cb = *(frame->base[ 2 ] + frame->pitches[ 2 ] * y / 2 + x / 2);
>+ break;
>+
>+ case XINE_IMGFMT_YUY2:
>+ Y = *(frame->base[ 0 ] + frame->pitches[ 0 ] * y + x * 2 + 0);
>+ x &= ~1;
>+ Cr = *(frame->base[ 0 ] + frame->pitches[ 0 ] * y + x * 2 + 1);
>+ Cb = *(frame->base[ 0 ] + frame->pitches[ 0 ] * y + x * 2 + 3);
>+ break;
>+ }
>+
>+ return (Y == 0x10 && Cr == 0x80 && Cb == 0x80);
>+}
>+
>+
>+static int expand_draw(vo_frame_t *frame, xine_stream_t *stream)
>+{
>+ post_video_port_t *port = (post_video_port_t *)frame->port;
>+ post_expand_t *this = (post_expand_t *)port->post;
>+ int skip;
>+
>+ if (this->centre_cut_out_mode && !frame->bad_frame)
>+ {
>+ /* expected area of inner 4:3 image */
>+ int centre_width = frame->width * (9 * 4) / (16 * 3);
>+ int centre_left = (frame->width - centre_width ) / 2;
>+
>+ /* centre point for detecting a black frame */
>+ int centre_x = frame->width / 2;
>+ int centre_y = frame->height / 2;
>+
>+ /* ignore a black frame as it could lead to wrong results */
>+ if (!is_pixel_black(frame, centre_x, centre_y))
>+ {
>+ /* coordinates for testing black border near the centre area */
>+ int test_left = centre_left - 16;
>+ int test_right = centre_left + 16 + centre_width;
>+
>+ /* enable cropping when these pixels are black */
>+ this->cropping_active = is_pixel_black(frame, test_left, centre_y)
>+ && is_pixel_black(frame, test_right, centre_y);
>+ }
>+
>+ /* crop frame */
>+ if (this->centre_cut_out_mode && this->cropping_active) {
>+ frame->crop_left += centre_left;
>+ frame->crop_right += centre_left;
>+
>+ /* get_frame() allocated an extra high frame */
>+ frame->crop_top += (frame->next->height - frame->height) / 2;
>+ frame->crop_bottom += (frame->next->height - frame->height) / 2;
>+ }
>+ }
>+
>+ _x_post_frame_copy_down(frame, frame->next);
>+ skip = frame->next->draw(frame->next, stream);
>+ _x_post_frame_copy_up(frame, frame->next);
>+
>+ return skip;
>+}
>diff -ruN xine-lib-1.1.1.orig/src/vdr/input_vdr.c xine-lib-1.1.1/src/vdr/input_vdr.c
>--- xine-lib-1.1.1.orig/src/vdr/input_vdr.c 1970-01-01 01:00:00.000000000 +0100
>+++ xine-lib-1.1.1/src/vdr/input_vdr.c 2006-01-02 20:15:09.000000000 +0100
>@@ -0,0 +1,1840 @@
>+/*
>+ * Copyright (C) 2003-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: input_vdr.c,v 1.51 2003/05/02 15:02:11 miguelfreitas Exp $
>+ */
>+
>+#ifdef HAVE_CONFIG_H
>+#include "config.h"
>+#endif
>+
>+#include <stdio.h>
>+#include <stdlib.h>
>+#include <string.h>
>+#include <fcntl.h>
>+#include <unistd.h>
>+#include <sys/stat.h>
>+#include <sys/poll.h>
>+#include <errno.h>
>+#include <pthread.h>
>+
>+#define LOG_MODULE "input_vdr"
>+#define LOG_VERBOSE
>+/*
>+#define LOG
>+*/
>+#include "xine_internal.h"
>+#include "xineutils.h"
>+#include "input_plugin.h"
>+
>+#include "input_vdr.h"
>+#include "post_vdr.h"
>+
>+
>+
>+#define VDR_MAX_NUM_WINDOWS 16
>+#define VDR_ABS_FIFO_DIR "/tmp/vdr-xine"
>+
>+
>+
>+#define BUF_SIZE 1024
>+
>+#define LOG_OSD(x)
>+/*
>+#define LOG_OSD(x) x
>+*/
>+
>+
>+typedef struct
>+{
>+ input_plugin_t input_plugin;
>+
>+ xine_stream_t *stream;
>+ xine_stream_t *stream_external;
>+
>+ int fh;
>+ int fh_control;
>+ int fh_result;
>+ int fh_event;
>+
>+ char *mrl;
>+
>+ off_t curpos;
>+ char seek_buf[ BUF_SIZE ];
>+
>+ char preview[ MAX_PREVIEW_SIZE ];
>+ off_t preview_size;
>+
>+ enum funcs cur_func;
>+ off_t cur_size;
>+ off_t cur_done;
>+
>+ xine_osd_t *osd_window[ VDR_MAX_NUM_WINDOWS ];
>+ uint8_t *osd_buffer;
>+ uint32_t osd_buffer_size;
>+ uint8_t osd_unscaled_blending;
>+
>+ uint8_t audio_channels;
>+ uint8_t trick_speed_mode;
>+ uint8_t mute_mode;
>+ uint8_t dont_change_xine_volume;
>+ int last_volume;
>+ vdr_frame_size_changed_data_t frame_size;
>+
>+ pthread_t rpc_thread;
>+ int rpc_thread_shutdown;
>+ pthread_mutex_t rpc_thread_shutdown_lock;
>+ pthread_cond_t rpc_thread_shutdown_cond;
>+
>+ xine_event_queue_t *event_queue;
>+ xine_event_queue_t *event_queue_external;
>+
>+}
>+vdr_input_plugin_t;
>+
>+
>+
>+typedef struct
>+{
>+ input_class_t input_class;
>+ xine_t *xine;
>+ char *mrls[ 2 ];
>+}
>+vdr_input_class_t;
>+
>+
>+
>+static int vdr_write(int f, void *b, int n)
>+{
>+ int t = 0, r;
>+
>+ while (t < n)
>+ {
>+ /*
>+ * System calls are not a thread cancellation point in Linux
>+ * pthreads. However, the RT signal sent to cancel the thread
>+ * will cause recv() to return with EINTR, and we can manually
>+ * check cancellation.
>+ */
>+ pthread_testcancel();
>+ r = write(f, ((char *)b) + t, n - t);
>+ pthread_testcancel();
>+
>+ if (r < 0
>+ && (errno == EINTR
>+ || errno == EAGAIN))
>+ {
>+ continue;
>+ }
>+
>+ if (r < 0)
>+ return r;
>+
>+ t += r;
>+ }
>+
>+ return t;
>+}
>+
>+
>+
>+static int internal_write_event_play_external(vdr_input_plugin_t *this, uint32_t key);
>+
>+static void event_handler_external(void *user_data, const xine_event_t *event)
>+{
>+ vdr_input_plugin_t *this = (vdr_input_plugin_t *)user_data;
>+ uint32_t key = key_none;
>+/*
>+ printf("event_handler_external(): event->type: %d\n", event->type);
>+*/
>+ switch (event->type)
>+ {
>+ case XINE_EVENT_UI_PLAYBACK_FINISHED:
>+ break;
>+
>+ default:
>+ return;
>+ }
>+
>+ if (0 != internal_write_event_play_external(this, key))
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ _(LOG_MODULE ": input event write: %s.\n"), strerror(errno));
>+}
>+
>+static void external_stream_stop(vdr_input_plugin_t *this)
>+{
>+ if (this->stream_external)
>+ {
>+ xine_stop(this->stream_external);
>+ xine_close(this->stream_external);
>+
>+ if (this->event_queue_external)
>+ {
>+ xine_event_dispose_queue(this->event_queue_external);
>+ this->event_queue_external = 0;
>+ }
>+
>+ _x_demux_flush_engine(this->stream_external);
>+
>+ xine_dispose(this->stream_external);
>+ this->stream_external = 0;
>+ }
>+}
>+
>+static void external_stream_play(vdr_input_plugin_t *this, char *file_name)
>+{
>+ external_stream_stop(this);
>+
>+ this->stream_external = xine_stream_new(this->stream->xine, this->stream->audio_out, this->stream->video_out);
>+
>+ this->event_queue_external = xine_event_new_queue(this->stream_external);
>+
>+ xine_event_create_listener_thread(this->event_queue_external, event_handler_external, this);
>+
>+ if (!xine_open(this->stream_external, file_name)
>+ || !xine_play(this->stream_external, 0, 0))
>+ {
>+ uint32_t key = key_none;
>+
>+ if ( 0 != internal_write_event_play_external(this, key))
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ _(LOG_MODULE ": input event write: %s.\n"), strerror(errno));
>+ }
>+}
>+
>+static off_t vdr_read_abort(xine_stream_t *stream, int fd, char *buf, off_t todo)
>+{
>+ off_t ret;
>+
>+ while (1)
>+ {
>+ /*
>+ * System calls are not a thread cancellation point in Linux
>+ * pthreads. However, the RT signal sent to cancel the thread
>+ * will cause recv() to return with EINTR, and we can manually
>+ * check cancellation.
>+ */
>+ pthread_testcancel();
>+ ret = _x_read_abort(stream, fd, buf, todo);
>+ pthread_testcancel();
>+
>+ if (ret < 0
>+ && (errno == EINTR
>+ || errno == EAGAIN))
>+ {
>+ continue;
>+ }
>+
>+ break;
>+ }
>+
>+ return ret;
>+}
>+
>+#define READ_DATA_OR_FAIL(kind, log) \
>+ data_##kind##_t *data = &data_union.kind; \
>+ { \
>+ log; \
>+ n = vdr_read_abort(this->stream, this->fh_control, (char *)data + sizeof (data->header), sizeof (*data) - sizeof (data->header)); \
>+ if (n != sizeof (*data) - sizeof (data->header)) \
>+ return -1; \
>+ \
>+ this->cur_size -= n; \
>+ }
>+
>+static double _now()
>+{
>+ struct timeval tv;
>+
>+ gettimeofday(&tv, 0);
>+
>+ return (tv.tv_sec * 1000000.0 + tv.tv_usec) / 1000.0;
>+}
>+
>+static off_t vdr_execute_rpc_command(vdr_input_plugin_t *this)
>+{
>+ data_union_t data_union;
>+ off_t n;
>+
>+ n = vdr_read_abort(this->stream, this->fh_control, (char *)&data_union, sizeof (data_union.header));
>+ if (n != sizeof (data_union.header))
>+ return -1;
>+
>+ this->cur_func = data_union.header.func;
>+ this->cur_size = data_union.header.len - sizeof (data_union.header);
>+ this->cur_done = 0;
>+
>+ switch (this->cur_func)
>+ {
>+ case func_nop:
>+ {
>+ READ_DATA_OR_FAIL(nop, lprintf("got NOP\n"));
>+ }
>+ break;
>+
>+ case func_osd_new:
>+ {
>+ READ_DATA_OR_FAIL(osd_new, LOG_OSD(lprintf("got OSDNEW\n")));
>+/*
>+ LOG_OSD(lprintf("... (%d,%d)-(%d,%d)\n", data->x, data->y, data->width, data->height));
>+
>+ fprintf(stderr, "vdr: osdnew %d\n", data->window);
>+*/
>+ if (data->window >= VDR_MAX_NUM_WINDOWS)
>+ return -1;
>+
>+ if (0 != this->osd_window[ data->window ])
>+ return -1;
>+
>+ this->osd_window[ data->window ] = xine_osd_new(this->stream
>+ , data->x
>+ , data->y
>+ , data->width
>+ , data->height);
>+
>+ if (0 == this->osd_window[ data->window ])
>+ return -1;
>+ }
>+ break;
>+
>+ case func_osd_free:
>+ {
>+ READ_DATA_OR_FAIL(osd_free, LOG_OSD(lprintf("got OSDFREE\n")));
>+/*
>+ fprintf(stderr, "vdr: osdfree %d\n", data->window);
>+*/
>+ if (data->window >= VDR_MAX_NUM_WINDOWS)
>+ return -1;
>+
>+ if (0 != this->osd_window[ data->window ])
>+ xine_osd_free(this->osd_window[ data->window ]);
>+
>+ this->osd_window[ data->window ] = 0;
>+ }
>+ break;
>+
>+ case func_osd_show:
>+ {
>+ READ_DATA_OR_FAIL(osd_show, LOG_OSD(lprintf("got OSDSHOW\n")));
>+/*
>+ fprintf(stderr, "vdr: osdshow %d\n", data->window);
>+*/
>+ if (data->window >= VDR_MAX_NUM_WINDOWS)
>+ return -1;
>+
>+ if (0 != this->osd_window[ data->window ])
>+ {
>+ if (this->osd_unscaled_blending)
>+ xine_osd_show_unscaled(this->osd_window[ data->window ], 0);
>+ else
>+ xine_osd_show(this->osd_window[ data->window ], 0);
>+ }
>+ }
>+ break;
>+
>+ case func_osd_hide:
>+ {
>+ READ_DATA_OR_FAIL(osd_hide, LOG_OSD(lprintf("got OSDHIDE\n")));
>+/*
>+ fprintf(stderr, "vdr: osdhide %d\n", data->window);
>+*/
>+ if (data->window >= VDR_MAX_NUM_WINDOWS)
>+ return -1;
>+
>+ if (0 != this->osd_window[ data->window ])
>+ {
>+ if (this->osd_unscaled_blending)
>+ xine_osd_show_unscaled(this->osd_window[ data->window ], 0);
>+ else
>+ xine_osd_show(this->osd_window[ data->window ], 0);
>+ }
>+ }
>+ break;
>+
>+ case func_osd_flush:
>+ {
>+ double _t1, _t2;
>+ int _n = 0;
>+
>+ READ_DATA_OR_FAIL(osd_flush, LOG_OSD(lprintf("got OSDFLUSH\n")));
>+/*
>+ fprintf(stderr, "vdr: osdflush +\n");
>+*/
>+ _t1 = _now();
>+
>+ while (_x_query_unprocessed_osd_events(this->stream))
>+ {
>+/*
>+ fprintf(stderr, "redraw_needed: 1\n");
>+*/
>+/* sched_yield(); */
>+ xine_usec_sleep(5000);
>+ _n++;
>+ }
>+
>+ _t2 = _now();
>+ fprintf(stderr, "vdr: osdflush: n: %d, %.1lf\n", _n, _t2 - _t1);
>+/*
>+ fprintf(stderr, "redraw_needed: 0\n");
>+
>+ fprintf(stderr, "vdr: osdflush -\n");
>+*/
>+ }
>+ break;
>+
>+ case func_osd_set_position:
>+ {
>+ READ_DATA_OR_FAIL(osd_set_position, LOG_OSD(lprintf("got OSDSETPOSITION\n")));
>+/*
>+ fprintf(stderr, "vdr: osdsetposition %d\n", data->window);
>+*/
>+ if (data->window >= VDR_MAX_NUM_WINDOWS)
>+ return -1;
>+
>+ if (0 != this->osd_window[ data->window ])
>+ xine_osd_set_position(this->osd_window[ data->window ], data->x, data->y);
>+ }
>+ break;
>+
>+ case func_osd_draw_bitmap:
>+ {
>+ READ_DATA_OR_FAIL(osd_draw_bitmap, LOG_OSD(lprintf("got OSDDRAWBITMAP\n")));
>+/*
>+ fprintf(stderr, "vdr: osddrawbitmap %d\n", data->window);
>+*/
>+ if (this->osd_buffer_size < this->cur_size)
>+ {
>+ if (this->osd_buffer)
>+ free(this->osd_buffer);
>+
>+ this->osd_buffer_size = 0;
>+
>+ this->osd_buffer = xine_xmalloc(this->cur_size);
>+ if (!this->osd_buffer)
>+ return -1;
>+
>+ this->osd_buffer_size = this->cur_size;
>+ }
>+
>+ n = vdr_read_abort (this->stream, this->fh_control, (char *)this->osd_buffer, this->cur_size);
>+ if (n != this->cur_size)
>+ return -1;
>+
>+ this->cur_size -= n;
>+
>+ if (data->window >= VDR_MAX_NUM_WINDOWS)
>+ return -1;
>+
>+ if (0 != this->osd_window[ data->window ])
>+ xine_osd_draw_bitmap(this->osd_window[ data->window ], this->osd_buffer, data->x, data->y, data->width, data->height, 0);
>+ }
>+ break;
>+
>+ case func_set_color:
>+ {
>+ uint32_t vdr_color[ 256 ];
>+
>+ READ_DATA_OR_FAIL(set_color, lprintf("got SETCOLOR\n"));
>+
>+ if (((data->num + 1) * sizeof (uint32_t)) != this->cur_size)
>+ return -1;
>+
>+ n = vdr_read_abort (this->stream, this->fh_control, (char *)&vdr_color[ data->index ], this->cur_size);
>+ if (n != this->cur_size)
>+ return -1;
>+
>+ this->cur_size -= n;
>+
>+ if (data->window >= VDR_MAX_NUM_WINDOWS)
>+ return -1;
>+
>+ if (0 != this->osd_window[ data->window ])
>+ {
>+ uint32_t color[ 256 ];
>+ uint8_t trans[ 256 ];
>+
>+ xine_osd_get_palette(this->osd_window[ data->window ], color, trans);
>+
>+ {
>+ int i;
>+
>+ for (i = data->index; i <= (data->index + data->num); i++)
>+ {
>+ int a = (vdr_color[ i ] & 0xff000000) >> 0x18;
>+ int r = (vdr_color[ i ] & 0x00ff0000) >> 0x10;
>+ int g = (vdr_color[ i ] & 0x0000ff00) >> 0x08;
>+ int b = (vdr_color[ i ] & 0x000000ff) >> 0x00;
>+
>+ int y = (( 66 * r + 129 * g + 25 * b + 128) >> 8) + 16;
>+ int cr = ((112 * r - 94 * g - 18 * b + 128) >> 8) + 128;
>+ int cb = ((-38 * r - 74 * g + 112 * b + 128) >> 8) + 128;
>+
>+ uint8_t *dst = (uint8_t *)&color[ i ];
>+ *dst++ = cb;
>+ *dst++ = cr;
>+ *dst++ = y;
>+ *dst++ = 0;
>+
>+ trans[ i ] = a >> 4;
>+ }
>+ }
>+
>+ xine_osd_set_palette(this->osd_window[ data->window ], color, trans);
>+ }
>+ }
>+ break;
>+
>+ case func_play_external:
>+ {
>+ char file_name[ 1024 ];
>+ int file_name_len = 0;
>+
>+ READ_DATA_OR_FAIL(play_external, lprintf("got PLAYEXTERNAL\n"));
>+
>+ file_name_len = this->cur_size;
>+
>+ if (0 != file_name_len)
>+ {
>+ if (file_name_len <= 1
>+ || file_name_len > sizeof (file_name))
>+ {
>+ return -1;
>+ }
>+
>+ n = vdr_read_abort (this->stream, this->fh_control, file_name, file_name_len);
>+ if (n != file_name_len)
>+ return -1;
>+
>+ if (file_name[ file_name_len - 1 ] != '\0')
>+ return -1;
>+
>+ this->cur_size -= n;
>+ }
>+
>+ lprintf((file_name_len > 0) ? "----------- play external: %s\n" : "---------- stop external\n", file_name);
>+
>+ if (file_name_len > 0)
>+ external_stream_play(this, file_name);
>+ else
>+ external_stream_stop(this);
>+ }
>+ break;
>+
>+ case func_clear:
>+ {
>+ READ_DATA_OR_FAIL(clear, lprintf("got CLEAR\n"));
>+
>+ {
>+fprintf(stderr, "+++ CLEAR(%d)\n", data->n);
>+/*
>+ if (!this->dont_change_xine_volume)
>+ xine_set_param(this->stream, XINE_PARAM_AUDIO_VOLUME, 0);
>+*/
>+ _x_demux_flush_engine(this->stream);
>+ _x_demux_seek(this->stream, 0, 0, 0);
>+
>+ _x_stream_info_reset(this->stream, XINE_STREAM_INFO_AUDIO_BITRATE);
>+ _x_meta_info_reset(this->stream, XINE_META_INFO_AUDIOCODEC);
>+
>+ _x_trigger_relaxed_frame_drop_mode(this->stream);
>+/* _x_reset_relaxed_frame_drop_mode(this->stream); */
>+/*
>+ if (!this->dont_change_xine_volume)
>+ xine_set_param(this->stream, XINE_PARAM_AUDIO_VOLUME, this->last_volume);
>+*/
>+fprintf(stderr, "--- CLEAR(%d)\n", data->n);
>+ }
>+ }
>+ break;
>+
>+ case func_first_frame:
>+ {
>+ READ_DATA_OR_FAIL(first_frame, lprintf("got FIRST FRAME\n"));
>+
>+ _x_trigger_relaxed_frame_drop_mode(this->stream);
>+/* _x_reset_relaxed_frame_drop_mode(this->stream); */
>+ }
>+ break;
>+
>+ case func_still_frame:
>+ {
>+ READ_DATA_OR_FAIL(still_frame, lprintf("got STILL FRAME\n"));
>+
>+ _x_reset_relaxed_frame_drop_mode(this->stream);
>+ }
>+ break;
>+
>+ case func_set_video_window:
>+ {
>+ READ_DATA_OR_FAIL(set_video_window, lprintf("got SET VIDEO WINDOW\n"));
>+/*
>+ fprintf(stderr, "svw: (%d, %d)x(%d, %d), (%d, %d)\n", data->x, data->y, data->w, data->h, data->wRef, data->hRef);
>+*/
>+ {
>+ xine_event_t event;
>+ vdr_set_video_window_data_t event_data;
>+
>+ event_data.x = data->x;
>+ event_data.y = data->y;
>+ event_data.w = data->w;
>+ event_data.h = data->h;
>+ event_data.w_ref = data->w_ref;
>+ event_data.h_ref = data->h_ref;
>+
>+ event.type = XINE_EVENT_VDR_SETVIDEOWINDOW;
>+ event.data = &event_data;
>+ event.data_length = sizeof (event_data);
>+
>+ xine_event_send(this->stream, &event);
>+ }
>+ }
>+ break;
>+
>+ case func_select_audio:
>+ {
>+ READ_DATA_OR_FAIL(select_audio, lprintf("got SELECT AUDIO\n"));
>+
>+ this->audio_channels = data->channels;
>+
>+ {
>+ xine_event_t event;
>+ vdr_select_audio_data_t event_data;
>+
>+ event_data.channels = this->audio_channels;
>+
>+ event.type = XINE_EVENT_VDR_SELECTAUDIO;
>+ event.data = &event_data;
>+ event.data_length = sizeof (event_data);
>+
>+ xine_event_send(this->stream, &event);
>+ }
>+ }
>+ break;
>+
>+ case func_trick_speed_mode:
>+ {
>+ READ_DATA_OR_FAIL(trick_speed_mode, lprintf("got TRICK SPEED MODE\n"));
>+
>+ this->trick_speed_mode = data->on;
>+
>+ _x_demux_seek(this->stream, 0, 0, 0);
>+
>+ {
>+ xine_event_t event;
>+
>+ event.type = XINE_EVENT_VDR_TRICKSPEEDMODE;
>+ event.data = 0;
>+ event.data_length = this->trick_speed_mode;
>+/* fprintf(stderr, "************************: %p, %d\n", event.data, event.data_length); */
>+ xine_event_send(this->stream, &event);
>+ }
>+ }
>+ break;
>+
>+ case func_flush:
>+ {
>+ READ_DATA_OR_FAIL(flush, lprintf("got FLUSH\n"));
>+
>+ if (!data->just_wait)
>+ {
>+ if (this->stream->video_fifo)
>+ {
>+ buf_element_t *buf = this->stream->video_fifo->buffer_pool_alloc(this->stream->video_fifo);
>+ if (!buf)
>+ {
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG, _(LOG_MODULE ": buffer_pool_alloc() failed!\n"));
>+ return -1;
>+ }
>+
>+ buf->type = BUF_CONTROL_FLUSH_DECODER;
>+
>+ this->stream->video_fifo->put(this->stream->video_fifo, buf);
>+ }
>+ }
>+
>+ {
>+ double _t1, _t2;
>+ int _n = 0;
>+
>+ int vb = -1, ab = -1, vf = -1, af = -1;
>+
>+ uint8_t timed_out = 0;
>+
>+ struct timeval now, then;
>+
>+ if (data->ms_timeout >= 0)
>+ {
>+ gettimeofday(&now, 0);
>+
>+ then = now;
>+ then.tv_usec += (data->ms_timeout % 1000) * 1000;
>+ then.tv_sec += (data->ms_timeout / 1000);
>+
>+ if (then.tv_usec >= 1000000)
>+ {
>+ then.tv_usec -= 1000000;
>+ then.tv_sec += 1;
>+ }
>+ }
>+ else
>+ {
>+ then.tv_usec = 0;
>+ then.tv_sec = 0;
>+ }
>+
>+ _t1 = _now();
>+
>+ while (1)
>+ {
>+ _x_query_buffer_usage(this->stream, &vb, &ab, &vf, &af);
>+
>+ if (vb <= 0 && ab <= 0 && vf <= 0 && af <= 0)
>+ break;
>+
>+ if (data->ms_timeout >= 0
>+ && timercmp(&now, &then, >))
>+ {
>+ timed_out++;
>+ break;
>+ }
>+
>+/* sched_yield(); */
>+ xine_usec_sleep(5000);
>+ _n++;
>+
>+ if (data->ms_timeout >= 0)
>+ gettimeofday(&now, 0);
>+ }
>+
>+ _t2 = _now();
>+ fprintf(stderr, "vdr: flush: n: %d, %.1lf\n", _n, _t2 - _t1);
>+
>+ xprintf(this->stream->xine
>+ , XINE_VERBOSITY_LOG
>+ , _(LOG_MODULE ": flush buffers (vb: %d, ab: %d, vf: %d, af: %d) %s.\n")
>+ , vb, ab, vf, af
>+ , (timed_out ? "timed out" : "done"));
>+
>+ {
>+ result_flush_t result_flush;
>+ result_flush.header.func = data->header.func;
>+ result_flush.header.len = sizeof (result_flush);
>+
>+ result_flush.timed_out = timed_out;
>+
>+ if (sizeof (result_flush) != vdr_write(this->fh_result, &result_flush, sizeof (result_flush)))
>+ return -1;
>+ }
>+ }
>+ }
>+ break;
>+
>+ case func_mute:
>+ {
>+ READ_DATA_OR_FAIL(mute, lprintf("got MUTE\n"));
>+
>+ xine_set_param(this->stream, XINE_PARAM_AUDIO_MUTE, data->mute);
>+ }
>+ break;
>+
>+ case func_set_volume:
>+ {
>+ READ_DATA_OR_FAIL(set_volume, lprintf("got SETVOLUME\n"));
>+
>+ {
>+ int change_volume = !this->dont_change_xine_volume;
>+ int do_mute = (0 != this->last_volume && 0 == data->volume);
>+ int do_unmute = (0 == this->last_volume && 0 != data->volume);
>+ int report_change = 0;
>+
>+ this->last_volume = data->volume;
>+
>+ if (do_mute || do_unmute)
>+ {
>+ switch (this->mute_mode)
>+ {
>+ case INPUT_VDR_MUTE_EXECUTE:
>+ report_change = 1;
>+ xine_set_param(this->stream, XINE_PARAM_AUDIO_MUTE, do_mute);
>+
>+ case INPUT_VDR_MUTE_IGNORE:
>+ if (do_mute)
>+ change_volume = 0;
>+ break;
>+
>+ case INPUT_VDR_MUTE_SIMULATE:
>+ change_volume = 1;
>+ break;
>+
>+ default:
>+ return -1;
>+ };
>+ }
>+
>+ if (change_volume)
>+ {
>+ report_change = 1;
>+ xine_set_param(this->stream, XINE_PARAM_AUDIO_VOLUME, this->last_volume);
>+ }
>+
>+ if (report_change)
>+ {
>+ xine_event_t event;
>+ xine_audio_level_data_t data;
>+
>+ data.left
>+ = data.right
>+ = xine_get_param(this->stream, XINE_PARAM_AUDIO_VOLUME);
>+ data.mute
>+ = xine_get_param(this->stream, XINE_PARAM_AUDIO_MUTE);
>+
>+ event.type = XINE_EVENT_AUDIO_LEVEL;
>+ event.data = &data;
>+ event.data_length = sizeof (data);
>+
>+ xine_event_send(this->stream, &event);
>+ }
>+ }
>+ }
>+ break;
>+
>+ case func_set_speed:
>+ {
>+ READ_DATA_OR_FAIL(set_speed, lprintf("got SETSPEED\n"));
>+
>+ lprintf("... got SETSPEED %d\n", data->speed);
>+
>+ if (data->speed != xine_get_param(this->stream, XINE_PARAM_FINE_SPEED))
>+ xine_set_param(this->stream, XINE_PARAM_FINE_SPEED, data->speed);
>+ }
>+ break;
>+
>+ case func_set_prebuffer:
>+ {
>+ READ_DATA_OR_FAIL(set_prebuffer, lprintf("got SETPREBUFFER\n"));
>+
>+ xine_set_param(this->stream, XINE_PARAM_METRONOM_PREBUFFER, data->prebuffer);
>+ }
>+ break;
>+
>+ case func_metronom:
>+ {
>+ READ_DATA_OR_FAIL(metronom, lprintf("got METRONOM\n"));
>+
>+ _x_demux_control_newpts(this->stream, data->pts, data->flags);
>+ }
>+ break;
>+
>+ case func_start:
>+ {
>+ READ_DATA_OR_FAIL(start, lprintf("got START\n"));
>+
>+ _x_demux_control_start(this->stream);
>+ _x_demux_seek(this->stream, 0, 0, 0);
>+ }
>+ break;
>+
>+ case func_wait:
>+ {
>+ READ_DATA_OR_FAIL(wait, lprintf("got WAIT\n"));
>+ }
>+ break;
>+
>+ case func_setup:
>+ {
>+ READ_DATA_OR_FAIL(setup, lprintf("got SETUP\n"));
>+
>+ this->osd_unscaled_blending = data->osd_unscaled_blending;
>+ this->dont_change_xine_volume = data->dont_change_xine_volume;
>+ this->mute_mode = data->mute_mode;
>+ }
>+ break;
>+
>+ case func_grab_image:
>+ {
>+ READ_DATA_OR_FAIL(grab_image, lprintf("got GRABIMAGE\n"));
>+
>+ {
>+ off_t ret_val = -1;
>+
>+ uint8_t *img = 0;
>+ int frame_size = 0;
>+ int width = 0;
>+ int height = 0;
>+ int ratio_code = 0;
>+ int format = 0;
>+
>+ int orig_speed = xine_get_param(this->stream, XINE_PARAM_FINE_SPEED);
>+ if (XINE_SPEED_PAUSE != orig_speed)
>+ xine_set_param(this->stream, XINE_PARAM_FINE_SPEED, XINE_SPEED_PAUSE);
>+
>+ if (xine_get_current_frame(this->stream, &width, &height, &ratio_code, &format, 0))
>+ {
>+ switch (format)
>+ {
>+ case XINE_IMGFMT_YV12:
>+ frame_size = width * height
>+ + ((width + 1) / 2) * ((height + 1) / 2)
>+ + ((width + 1) / 2) * ((height + 1) / 2);
>+ break;
>+
>+ case XINE_IMGFMT_YUY2:
>+ frame_size = width * height
>+ + ((width + 1) / 2) * height
>+ + ((width + 1) / 2) * height;
>+ break;
>+ }
>+
>+ img = xine_xmalloc(frame_size);
>+
>+ if (!xine_get_current_frame(this->stream, &width, &height, &ratio_code, &format, img))
>+ frame_size = 0;
>+
>+ if (ratio_code == XINE_VO_ASPECT_SQUARE)
>+ ratio_code = 10000;
>+ else if (ratio_code == XINE_VO_ASPECT_4_3)
>+ ratio_code = 13333;
>+ else if (ratio_code == XINE_VO_ASPECT_ANAMORPHIC)
>+ ratio_code = 17778;
>+ else if (ratio_code == XINE_VO_ASPECT_DVB)
>+ ratio_code = 21100;
>+
>+ if (0 == frame_size)
>+ {
>+ width = 0;
>+ height = 0;
>+ ratio_code = 0;
>+ }
>+ }
>+
>+ if (XINE_SPEED_PAUSE != orig_speed)
>+ xine_set_param(this->stream, XINE_PARAM_FINE_SPEED, orig_speed);
>+
>+ {
>+ result_grab_image_t result_grab_image;
>+ result_grab_image.header.func = data->header.func;
>+ result_grab_image.header.len = sizeof (result_grab_image) + frame_size;
>+
>+ result_grab_image.width = width;
>+ result_grab_image.height = height;
>+ result_grab_image.ratio = ratio_code;
>+ result_grab_image.format = format;
>+
>+ if (sizeof (result_grab_image) == vdr_write(this->fh_result, &result_grab_image, sizeof (result_grab_image)))
>+ {
>+ if (frame_size == vdr_write(this->fh_result, img, frame_size))
>+ ret_val = 0;
>+ }
>+ }
>+
>+ if (img)
>+ free(img);
>+
>+ if (ret_val != 0)
>+ return ret_val;
>+ }
>+ }
>+ break;
>+
>+ case func_get_pts:
>+ {
>+ READ_DATA_OR_FAIL(get_pts, lprintf("got GETPTS\n"));
>+
>+ {
>+ result_get_pts_t result_get_pts;
>+ result_get_pts.header.func = data->header.func;
>+ result_get_pts.header.len = sizeof (result_get_pts);
>+
>+ result_get_pts.pts = xine_get_current_vpts(this->stream) - this->stream->metronom->get_option(this->stream->metronom, METRONOM_VPTS_OFFSET);
>+
>+ if (sizeof (result_get_pts) != vdr_write(this->fh_result, &result_get_pts, sizeof (result_get_pts)))
>+ return -1;
>+ }
>+ }
>+ break;
>+
>+ case func_video_size:
>+ {
>+ READ_DATA_OR_FAIL(video_size, lprintf("got VIDEO SIZE\n"));
>+
>+ {
>+ int format;
>+
>+ result_video_size_t result_video_size;
>+ result_video_size.header.func = data->header.func;
>+ result_video_size.header.len = sizeof (result_video_size);
>+
>+ result_video_size.top = -1;
>+ result_video_size.left = -1;
>+ result_video_size.width = -1;
>+ result_video_size.height = -1;
>+ result_video_size.ratio = 0;
>+
>+ xine_get_current_frame(this->stream, &result_video_size.width, &result_video_size.height, &result_video_size.ratio, &format, 0);
>+
>+ if (result_video_size.ratio == XINE_VO_ASPECT_SQUARE)
>+ result_video_size.ratio = 10000;
>+ else if (result_video_size.ratio == XINE_VO_ASPECT_4_3)
>+ result_video_size.ratio = 13333;
>+ else if (result_video_size.ratio == XINE_VO_ASPECT_ANAMORPHIC)
>+ result_video_size.ratio = 17778;
>+ else if (result_video_size.ratio == XINE_VO_ASPECT_DVB)
>+ result_video_size.ratio = 21100;
>+
>+ if (0 != this->frame_size.x
>+ || 0 != this->frame_size.y
>+ || 0 != this->frame_size.w
>+ || 0 != this->frame_size.h)
>+ {
>+ result_video_size.left = this->frame_size.x;
>+ result_video_size.top = this->frame_size.y;
>+ result_video_size.width = this->frame_size.w;
>+ result_video_size.height = this->frame_size.h;
>+ }
>+
>+ if (sizeof (result_video_size) != vdr_write(this->fh_result, &result_video_size, sizeof (result_video_size)))
>+ return -1;
>+ }
>+ }
>+ break;
>+
>+ case func_reset_audio:
>+ {
>+ double _t1, _t2;
>+ int _n = 0;
>+
>+ READ_DATA_OR_FAIL(reset_audio, lprintf("got RESET AUDIO\n"));
>+
>+ if (this->stream->audio_fifo)
>+ {
>+ xine_set_param(this->stream, XINE_PARAM_IGNORE_AUDIO, 1);
>+ xine_set_param(this->stream, XINE_PARAM_AUDIO_CHANNEL_LOGICAL, -2);
>+
>+ _t1 = _now();
>+
>+ while (1)
>+ {
>+ int n = xine_get_stream_info(this->stream, XINE_STREAM_INFO_MAX_AUDIO_CHANNEL);
>+ if (n <= 0)
>+ break;
>+
>+ /* keep the decoder running */
>+ if (this->stream->audio_fifo)
>+ {
>+ buf_element_t *buf = this->stream->audio_fifo->buffer_pool_alloc(this->stream->audio_fifo);
>+ if (!buf)
>+ {
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG, _(LOG_MODULE ": buffer_pool_alloc() failed!\n"));
>+ return -1;
>+ }
>+
>+ buf->type = BUF_CONTROL_NOP;
>+
>+ this->stream->audio_fifo->put(this->stream->audio_fifo, buf);
>+ }
>+
>+/* sched_yield(); */
>+ xine_usec_sleep(5000);
>+ _n++;
>+ }
>+
>+ _t2 = _now();
>+ fprintf(stderr, "vdr: reset_audio: n: %d, %.1lf\n", _n, _t2 - _t1);
>+
>+ xine_set_param(this->stream, XINE_PARAM_AUDIO_CHANNEL_LOGICAL, -1);
>+
>+ _x_stream_info_reset(this->stream, XINE_STREAM_INFO_AUDIO_BITRATE);
>+ _x_meta_info_reset(this->stream, XINE_META_INFO_AUDIOCODEC);
>+
>+ xine_set_param(this->stream, XINE_PARAM_IGNORE_AUDIO, 0);
>+ }
>+ }
>+ break;
>+
>+ default:
>+ lprintf("unknown function: %d\n", this->cur_func);
>+ }
>+
>+ if (this->cur_size != this->cur_done)
>+ {
>+ off_t skip = this->cur_size - this->cur_done;
>+
>+ lprintf("func: %d, skipping: %lld\n", this->cur_func, skip);
>+
>+ while (skip > BUF_SIZE)
>+ {
>+ n = vdr_read_abort(this->stream, this->fh_control, this->seek_buf, BUF_SIZE);
>+ if (n != BUF_SIZE)
>+ return -1;
>+
>+ skip -= BUF_SIZE;
>+ }
>+
>+ n = vdr_read_abort(this->stream, this->fh_control, this->seek_buf, skip);
>+ if (n != skip)
>+ return -1;
>+
>+ this->cur_done = this->cur_size;
>+
>+ return -1;
>+ }
>+
>+ return 0;
>+}
>+
>+static void *vdr_rpc_thread_loop(void *arg)
>+{
>+ vdr_input_plugin_t *this = (vdr_input_plugin_t *)arg;
>+ int frontend_lock_failures = 0;
>+ int failed = 0;
>+
>+ while (!failed
>+ && !this->rpc_thread_shutdown)
>+ {
>+ struct timeval timeout;
>+ fd_set rset;
>+
>+ FD_ZERO(&rset);
>+ FD_SET(this->fh_control, &rset);
>+
>+ timeout.tv_sec = 0;
>+ timeout.tv_usec = 50000;
>+
>+ if (select(this->fh_control + 1, &rset, NULL, NULL, &timeout) > 0)
>+ {
>+ if (!_x_lock_frontend(this->stream, 100))
>+ {
>+ if (++frontend_lock_failures > 50)
>+ {
>+ failed = 1;
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ LOG_MODULE ": locking frontend for rpc command execution failed, exiting ...\n");
>+ }
>+ }
>+ else
>+ {
>+ frontend_lock_failures = 0;
>+
>+ if (vdr_execute_rpc_command(this) < 0)
>+ {
>+ failed = 1;
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ LOG_MODULE ": execution of rpc command %d (%s) failed, exiting ...\n", this->cur_func, "");
>+ }
>+
>+ _x_unlock_frontend(this->stream);
>+ }
>+ }
>+ }
>+
>+ /* close control and result channel here to have vdr-xine initiate a disconnect for the above error case ... */
>+ close(this->fh_control);
>+ this->fh_control = -1;
>+
>+ close(this->fh_result);
>+ this->fh_result = -1;
>+
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ LOG_MODULE ": rpc thread done.\n");
>+
>+ pthread_mutex_lock(&this->rpc_thread_shutdown_lock);
>+ this->rpc_thread_shutdown = -1;
>+ pthread_cond_broadcast(&this->rpc_thread_shutdown_cond);
>+ pthread_mutex_unlock(&this->rpc_thread_shutdown_lock);
>+
>+ return 0;
>+}
>+
>+static int internal_write_event_key(vdr_input_plugin_t *this, uint32_t key)
>+{
>+ event_key_t event;
>+ event.header.func = func_key;
>+ event.header.len = sizeof (event);
>+
>+ event.key = key;
>+
>+ if (sizeof (event) != vdr_write(this->fh_event, &event, sizeof (event)))
>+ return -1;
>+
>+ return 0;
>+}
>+
>+static int internal_write_event_frame_size(vdr_input_plugin_t *this)
>+{
>+ event_frame_size_t event;
>+ event.header.func = func_frame_size;
>+ event.header.len = sizeof (event);
>+
>+ event.top = this->frame_size.x;
>+ event.left = this->frame_size.y;
>+ event.width = this->frame_size.w,
>+ event.height = this->frame_size.h;
>+
>+ if (sizeof (event) != vdr_write(this->fh_event, &event, sizeof (event)))
>+ return -1;
>+
>+ return 0;
>+}
>+
>+static int internal_write_event_play_external(vdr_input_plugin_t *this, uint32_t key)
>+{
>+ event_play_external_t event;
>+ event.header.func = func_play_external;
>+ event.header.len = sizeof (event);
>+
>+ event.key = key;
>+
>+ if (sizeof (event) != vdr_write(this->fh_event, &event, sizeof (event)))
>+ return -1;
>+
>+ return 0;
>+}
>+
>+static off_t vdr_plugin_read(input_plugin_t *this_gen,
>+ char *buf, off_t len)
>+{
>+ vdr_input_plugin_t *this = (vdr_input_plugin_t *) this_gen;
>+ off_t n, total;
>+#ifdef LOG_READ
>+ lprintf ("reading %lld bytes...\n", len);
>+#endif
>+ total=0;
>+ if (this->curpos < this->preview_size)
>+ {
>+ n = this->preview_size - this->curpos;
>+ if (n > (len - total))
>+ n = len - total;
>+#ifdef LOG_READ
>+ lprintf ("%lld bytes from preview (which has %lld bytes)\n",
>+ n, this->preview_size);
>+#endif
>+ memcpy (&buf[total], &this->preview[this->curpos], n);
>+ this->curpos += n;
>+ total += n;
>+ }
>+
>+ if( (len-total) > 0 )
>+ {
>+ int retries = 0;
>+ do
>+ {
>+ n = vdr_read_abort (this->stream, this->fh, &buf[total], len-total);
>+ if (0 == n)
>+ lprintf("read 0, retries: %d\n", retries);
>+ }
>+ while (0 == n
>+ && !this->stream_external
>+ && _x_continue_stream_processing(this->stream)
>+ && 200 > retries++); /* 200 * 50ms */
>+#ifdef LOG_READ
>+ lprintf ("got %lld bytes (%lld/%lld bytes read)\n",
>+ n,total,len);
>+#endif
>+ if (n < 0)
>+ {
>+ _x_message(this->stream, XINE_MSG_READ_ERROR, NULL);
>+ return 0;
>+ }
>+
>+ this->curpos += n;
>+ total += n;
>+ }
>+ return total;
>+}
>+
>+static buf_element_t *vdr_plugin_read_block(input_plugin_t *this_gen, fifo_buffer_t *fifo,
>+ off_t todo)
>+{
>+ off_t total_bytes;
>+ buf_element_t *buf = fifo->buffer_pool_alloc(fifo);
>+
>+ buf->content = buf->mem;
>+ buf->type = BUF_DEMUX_BLOCK;
>+
>+ total_bytes = vdr_plugin_read(this_gen, (char *)buf->content, todo);
>+
>+ if (total_bytes != todo)
>+ {
>+ buf->free_buffer(buf);
>+ return NULL;
>+ }
>+
>+ buf->size = total_bytes;
>+
>+ return buf;
>+}
>+
>+/* forward reference */
>+static off_t vdr_plugin_get_current_pos(input_plugin_t *this_gen);
>+
>+static off_t vdr_plugin_seek(input_plugin_t *this_gen, off_t offset, int origin)
>+{
>+ vdr_input_plugin_t *this = (vdr_input_plugin_t *)this_gen;
>+
>+ lprintf("seek %lld offset, %d origin...\n",
>+ offset, origin);
>+
>+ if ((origin == SEEK_CUR) && (offset >= 0))
>+ {
>+ for ( ; ((int)offset) - BUF_SIZE > 0; offset -= BUF_SIZE)
>+ {
>+ if (!this_gen->read(this_gen, this->seek_buf, BUF_SIZE))
>+ return this->curpos;
>+ }
>+
>+ this_gen->read (this_gen, this->seek_buf, offset);
>+ }
>+
>+ if (origin == SEEK_SET)
>+ {
>+ if (offset < this->curpos)
>+ {
>+ if (this->curpos <= this->preview_size)
>+ this->curpos = offset;
>+ else
>+ lprintf("cannot seek back! (%lld > %lld)\n", this->curpos, offset);
>+ }
>+ else
>+ {
>+ offset -= this->curpos;
>+
>+ for ( ; ((int)offset) - BUF_SIZE > 0; offset -= BUF_SIZE)
>+ {
>+ if (!this_gen->read(this_gen, this->seek_buf, BUF_SIZE))
>+ return this->curpos;
>+ }
>+
>+ this_gen->read(this_gen, this->seek_buf, offset);
>+ }
>+ }
>+
>+ return this->curpos;
>+}
>+
>+static off_t vdr_plugin_get_length(input_plugin_t *this_gen)
>+{
>+ return 0;
>+}
>+
>+static uint32_t vdr_plugin_get_capabilities(input_plugin_t *this_gen)
>+{
>+ /* return INPUT_CAP_PREVIEW; */
>+ return INPUT_CAP_NOCAP;
>+}
>+
>+static uint32_t vdr_plugin_get_blocksize(input_plugin_t *this_gen)
>+{
>+ return 0;
>+}
>+
>+static off_t vdr_plugin_get_current_pos(input_plugin_t *this_gen)
>+{
>+ vdr_input_plugin_t *this = (vdr_input_plugin_t *)this_gen;
>+
>+ return this->curpos;
>+}
>+
>+static char* vdr_plugin_get_mrl(input_plugin_t *this_gen)
>+{
>+ vdr_input_plugin_t *this = (vdr_input_plugin_t *)this_gen;
>+
>+ return this->mrl;
>+}
>+
>+static void vdr_plugin_dispose(input_plugin_t *this_gen)
>+{
>+ vdr_input_plugin_t *this = (vdr_input_plugin_t *)this_gen;
>+ int i;
>+
>+ external_stream_stop(this);
>+
>+ if (this->event_queue)
>+ xine_event_dispose_queue(this->event_queue);
>+
>+ if (this->rpc_thread)
>+ {
>+ struct timespec abstime;
>+ int ms_to_time_out = 10000;
>+
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG, _(LOG_MODULE ": shutting down rpc thread (timeout: %d ms) ...\n"), ms_to_time_out);
>+
>+ pthread_mutex_lock(&this->rpc_thread_shutdown_lock);
>+
>+ if (this->rpc_thread_shutdown > -1)
>+ {
>+ this->rpc_thread_shutdown = 1;
>+
>+ {
>+ struct timeval now;
>+ gettimeofday(&now, 0);
>+
>+ abstime.tv_sec = now.tv_sec + ms_to_time_out / 1000;
>+ abstime.tv_nsec = now.tv_usec * 1000 + (ms_to_time_out % 1000) * 1e6;
>+
>+ if (abstime.tv_nsec > 1e9)
>+ {
>+ abstime.tv_nsec -= 1e9;
>+ abstime.tv_sec++;
>+ }
>+ }
>+
>+ if (0 != pthread_cond_timedwait(&this->rpc_thread_shutdown_cond, &this->rpc_thread_shutdown_lock, &abstime))
>+ {
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG, _(LOG_MODULE ": cancelling rpc thread ...\n"));
>+ pthread_cancel(this->rpc_thread);
>+ }
>+ }
>+
>+ pthread_mutex_unlock(&this->rpc_thread_shutdown_lock);
>+
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG, _(LOG_MODULE ": joining rpc thread ...\n"));
>+ pthread_join(this->rpc_thread, 0);
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG, _(LOG_MODULE ": rpc thread joined.\n"));
>+ }
>+
>+ pthread_cond_destroy(&this->rpc_thread_shutdown_cond);
>+ pthread_mutex_destroy(&this->rpc_thread_shutdown_lock);
>+
>+ if (this->fh_result != -1)
>+ close(this->fh_result);
>+
>+ if (this->fh_control != -1)
>+ close(this->fh_control);
>+
>+ if (this->fh_event != -1)
>+ close(this->fh_event);
>+
>+ for (i = 0; i < VDR_MAX_NUM_WINDOWS; i++)
>+ {
>+ if (0 == this->osd_window[ i ])
>+ continue;
>+
>+ xine_osd_hide(this->osd_window[ i ], 0);
>+ xine_osd_free(this->osd_window[ i ]);
>+ }
>+
>+ if (this->osd_buffer)
>+ free(this->osd_buffer);
>+
>+ if ((this->fh != STDIN_FILENO) && (this->fh != -1))
>+ close(this->fh);
>+
>+ free(this->mrl);
>+ free(this);
>+}
>+
>+static int vdr_plugin_get_optional_data(input_plugin_t *this_gen,
>+ void *data, int data_type)
>+{
>+/*
>+ vdr_input_plugin_t *this = (vdr_input_plugin_t *)this_gen;
>+
>+ switch (data_type)
>+ {
>+ case INPUT_OPTIONAL_DATA_PREVIEW:
>+ memcpy (data, this->preview, this->preview_size);
>+ return this->preview_size;
>+ }
>+*/
>+ return INPUT_OPTIONAL_UNSUPPORTED;
>+}
>+
>+static int vdr_plugin_open(input_plugin_t *this_gen)
>+{
>+ vdr_input_plugin_t *this = (vdr_input_plugin_t *)this_gen;
>+
>+ lprintf("trying to open '%s'...\n", this->mrl);
>+
>+ if (this->fh == -1)
>+ {
>+ char *filename;
>+ int err = 0;
>+
>+ filename = (char *)&this->mrl[ 4 ];
>+ this->fh = open(filename, O_RDONLY | O_NONBLOCK);
>+
>+ lprintf("filename '%s'\n", filename);
>+
>+ if (this->fh == -1)
>+ {
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ _(LOG_MODULE ": failed to open '%s' (%s)\n"),
>+ filename,
>+ strerror(errno));
>+
>+ return 0;
>+ }
>+
>+ {
>+ struct pollfd poll_fh = { this->fh, POLLIN, 0 };
>+
>+ int r = poll(&poll_fh, 1, 300);
>+ if (1 != r)
>+ {
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ _(LOG_MODULE ": failed to open '%s' (%s)\n"),
>+ filename,
>+ _("timeout expired during setup phase"));
>+
>+ return 0;
>+ }
>+ }
>+
>+ fcntl(this->fh, F_SETFL, ~O_NONBLOCK & fcntl(this->fh, F_GETFL, 0));
>+
>+ {
>+ char *filename_control = 0;
>+ asprintf(&filename_control, "%s.control", filename);
>+
>+ this->fh_control = open(filename_control, O_RDONLY);
>+
>+ if (this->fh_control == -1) {
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ _(LOG_MODULE ": failed to open '%s' (%s)\n"),
>+ filename_control,
>+ strerror(errno));
>+
>+ free(filename_control);
>+ return 0;
>+ }
>+
>+ free(filename_control);
>+ }
>+
>+ {
>+ char *filename_result = 0;
>+ asprintf(&filename_result, "%s.result", filename);
>+
>+ this->fh_result = open(filename_result, O_WRONLY);
>+
>+ if (this->fh_result == -1) {
>+ perror("failed");
>+
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ _(LOG_MODULE ": failed to open '%s' (%s)\n"),
>+ filename_result,
>+ strerror(errno));
>+
>+ free(filename_result);
>+ return 0;
>+ }
>+
>+ free(filename_result);
>+ }
>+
>+ {
>+ char *filename_event = 0;
>+ asprintf(&filename_event, "%s.event", filename);
>+
>+ this->fh_event = open(filename_event, O_WRONLY);
>+
>+ if (this->fh_event == -1) {
>+ perror("failed");
>+
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ _(LOG_MODULE ": failed to open '%s' (%s)\n"),
>+ filename_event,
>+ strerror(errno));
>+
>+ free(filename_event);
>+ return 0;
>+ }
>+
>+ free(filename_event);
>+ }
>+
>+ this->rpc_thread_shutdown = 0;
>+ if ((err = pthread_create(&this->rpc_thread, NULL,
>+ vdr_rpc_thread_loop, (void *)this)) != 0)
>+ {
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ _(LOG_MODULE ": can't create new thread (%s)\n"),
>+ strerror(err));
>+
>+ return 0;
>+ }
>+ }
>+
>+
>+ /*
>+ * mrl accepted and opened successfully at this point
>+ *
>+ * => create plugin instance
>+ */
>+
>+ /*
>+ * fill preview buffer
>+ */
>+
>+ this->preview_size = 0; /* vdr_plugin_read (&this->input_plugin, this->preview,
>+ MAX_PREVIEW_SIZE) */
>+ this->curpos = 0;
>+
>+ return 1;
>+}
>+
>+static void event_handler(void *user_data, const xine_event_t *event)
>+{
>+ vdr_input_plugin_t *this = (vdr_input_plugin_t *)user_data;
>+ uint32_t key = key_none;
>+
>+ lprintf("eventHandler(): event->type: %d\n", event->type);
>+
>+ if (XINE_EVENT_VDR_FRAMESIZECHANGED == event->type)
>+ {
>+ memcpy(&this->frame_size, event->data, event->data_length);
>+
>+ if (0 != internal_write_event_frame_size(this))
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ _(LOG_MODULE ": input event write: %s.\n"), strerror(errno));
>+
>+ return;
>+ }
>+ else if (XINE_EVENT_VDR_PLUGINSTARTED == event->type)
>+ {
>+ if (0 == event->data_length) /* vdr_video */
>+ {
>+ xine_event_t event;
>+
>+ event.type = XINE_EVENT_VDR_TRICKSPEEDMODE;
>+ event.data = 0;
>+ event.data_length = this->trick_speed_mode;
>+
>+ xine_event_send(this->stream, &event);
>+ }
>+ else if (1 == event->data_length) /* vdr_audio */
>+ {
>+ xine_event_t event;
>+ vdr_select_audio_data_t event_data;
>+
>+ event_data.channels = this->audio_channels;
>+
>+ event.type = XINE_EVENT_VDR_SELECTAUDIO;
>+ event.data = &event_data;
>+ event.data_length = sizeof (event_data);
>+
>+ xine_event_send(this->stream, &event);
>+ }
>+ else
>+ {
>+ fprintf(stderr, "input_vdr: illegal XINE_EVENT_VDR_PLUGINSTARTED: %d\n", event->data_length);
>+ }
>+ }
>+
>+ switch (event->type)
>+ {
>+ case XINE_EVENT_INPUT_UP: key = key_up; break;
>+ case XINE_EVENT_INPUT_DOWN: key = key_down; break;
>+ case XINE_EVENT_INPUT_LEFT: key = key_left; break;
>+ case XINE_EVENT_INPUT_RIGHT: key = key_right; break;
>+ case XINE_EVENT_INPUT_SELECT: key = key_ok; break;
>+ case XINE_EVENT_VDR_BACK: key = key_back; break;
>+ case XINE_EVENT_VDR_CHANNELPLUS: key = key_channel_plus; break;
>+ case XINE_EVENT_VDR_CHANNELMINUS: key = key_channel_minus; break;
>+ case XINE_EVENT_VDR_RED: key = key_red; break;
>+ case XINE_EVENT_VDR_GREEN: key = key_green; break;
>+ case XINE_EVENT_VDR_YELLOW: key = key_yellow; break;
>+ case XINE_EVENT_VDR_BLUE: key = key_blue; break;
>+ case XINE_EVENT_VDR_PLAY: key = key_play; break;
>+ case XINE_EVENT_VDR_PAUSE: key = key_pause; break;
>+ case XINE_EVENT_VDR_STOP: key = key_stop; break;
>+ case XINE_EVENT_VDR_RECORD: key = key_record; break;
>+ case XINE_EVENT_VDR_FASTFWD: key = key_fast_fwd; break;
>+ case XINE_EVENT_VDR_FASTREW: key = key_fast_rew; break;
>+ case XINE_EVENT_VDR_POWER: key = key_power; break;
>+ case XINE_EVENT_VDR_SCHEDULE: key = key_schedule; break;
>+ case XINE_EVENT_VDR_CHANNELS: key = key_channels; break;
>+ case XINE_EVENT_VDR_TIMERS: key = key_timers; break;
>+ case XINE_EVENT_VDR_RECORDINGS: key = key_recordings; break;
>+ case XINE_EVENT_INPUT_MENU1: key = key_menu; break;
>+ case XINE_EVENT_VDR_SETUP: key = key_setup; break;
>+ case XINE_EVENT_VDR_COMMANDS: key = key_commands; break;
>+ case XINE_EVENT_INPUT_NUMBER_0: key = key_0; break;
>+ case XINE_EVENT_INPUT_NUMBER_1: key = key_1; break;
>+ case XINE_EVENT_INPUT_NUMBER_2: key = key_2; break;
>+ case XINE_EVENT_INPUT_NUMBER_3: key = key_3; break;
>+ case XINE_EVENT_INPUT_NUMBER_4: key = key_4; break;
>+ case XINE_EVENT_INPUT_NUMBER_5: key = key_5; break;
>+ case XINE_EVENT_INPUT_NUMBER_6: key = key_6; break;
>+ case XINE_EVENT_INPUT_NUMBER_7: key = key_7; break;
>+ case XINE_EVENT_INPUT_NUMBER_8: key = key_8; break;
>+ case XINE_EVENT_INPUT_NUMBER_9: key = key_9; break;
>+ case XINE_EVENT_VDR_USER1: key = key_user1; break;
>+ case XINE_EVENT_VDR_USER2: key = key_user2; break;
>+ case XINE_EVENT_VDR_USER3: key = key_user3; break;
>+ case XINE_EVENT_VDR_USER4: key = key_user4; break;
>+ case XINE_EVENT_VDR_USER5: key = key_user5; break;
>+ case XINE_EVENT_VDR_USER6: key = key_user6; break;
>+ case XINE_EVENT_VDR_USER7: key = key_user7; break;
>+ case XINE_EVENT_VDR_USER8: key = key_user8; break;
>+ case XINE_EVENT_VDR_USER9: key = key_user9; break;
>+ case XINE_EVENT_VDR_VOLPLUS: key = key_volume_plus; break;
>+ case XINE_EVENT_VDR_VOLMINUS: key = key_volume_minus; break;
>+ case XINE_EVENT_VDR_MUTE: key = key_mute; break;
>+ case XINE_EVENT_VDR_AUDIO: key = key_audio; break;
>+ default:
>+ return;
>+ }
>+
>+ if (0 != internal_write_event_key(this, key))
>+ xprintf(this->stream->xine, XINE_VERBOSITY_LOG,
>+ _(LOG_MODULE ": input event write: %s.\n"), strerror(errno));
>+}
>+
>+static input_plugin_t *vdr_class_get_instance(input_class_t *cls_gen, xine_stream_t *stream,
>+ const char *data)
>+{
>+ vdr_input_plugin_t *this;
>+ char *mrl = strdup(data);
>+
>+ if (!strncasecmp(mrl, "vdr:/", 5))
>+ {
>+ lprintf("filename '%s'\n", (char *)&mrl[ 4 ]);
>+ }
>+ else
>+ {
>+ free(mrl);
>+ return NULL;
>+ }
>+
>+ /*
>+ * mrl accepted and opened successfully at this point
>+ *
>+ * => create plugin instance
>+ */
>+
>+ this = (vdr_input_plugin_t *)xine_xmalloc(sizeof (vdr_input_plugin_t));
>+
>+ this->stream = stream;
>+ this->curpos = 0;
>+ this->mrl = mrl;
>+ this->fh = -1;
>+ this->fh_control = -1;
>+ this->fh_result = -1;
>+ this->fh_event = -1;
>+
>+ this->input_plugin.open = vdr_plugin_open;
>+ this->input_plugin.get_capabilities = vdr_plugin_get_capabilities;
>+ this->input_plugin.read = vdr_plugin_read;
>+ this->input_plugin.read_block = vdr_plugin_read_block;
>+ this->input_plugin.seek = vdr_plugin_seek;
>+ this->input_plugin.get_current_pos = vdr_plugin_get_current_pos;
>+ this->input_plugin.get_length = vdr_plugin_get_length;
>+ this->input_plugin.get_blocksize = vdr_plugin_get_blocksize;
>+ this->input_plugin.get_mrl = vdr_plugin_get_mrl;
>+ this->input_plugin.dispose = vdr_plugin_dispose;
>+ this->input_plugin.get_optional_data = vdr_plugin_get_optional_data;
>+ this->input_plugin.input_class = cls_gen;
>+
>+ this->cur_func = func_unknown;
>+ this->cur_size = 0;
>+ this->cur_done = 0;
>+
>+ memset(this->osd_window, 0, sizeof (this->osd_window));
>+
>+ this->osd_buffer = 0;
>+ this->osd_buffer_size = 0;
>+ this->osd_unscaled_blending = 0;
>+ this->trick_speed_mode = 0;
>+ this->audio_channels = 0;
>+ this->mute_mode = INPUT_VDR_MUTE_SIMULATE;
>+ this->dont_change_xine_volume = 0;
>+ this->last_volume = 0;
>+ this->frame_size.x = 0;
>+ this->frame_size.y = 0;
>+ this->frame_size.w = 0;
>+ this->frame_size.h = 0;
>+
>+ this->stream_external = 0;
>+ this->event_queue_external = 0;
>+
>+ pthread_mutex_init(&this->rpc_thread_shutdown_lock, 0);
>+ pthread_cond_init(&this->rpc_thread_shutdown_cond, 0);
>+
>+ this->event_queue = xine_event_new_queue(this->stream);
>+ if (this->event_queue)
>+ xine_event_create_listener_thread(this->event_queue, event_handler, this);
>+
>+ return &this->input_plugin;
>+}
>+
>+/*
>+ * vdr input plugin class stuff
>+ */
>+
>+static char *vdr_class_get_description(input_class_t *this_gen)
>+{
>+ return _("VDR display device plugin");
>+}
>+
>+static const char *vdr_class_get_identifier (input_class_t *this_gen)
>+{
>+ return "VDR";
>+}
>+
>+static void vdr_class_dispose (input_class_t *this_gen)
>+{
>+ vdr_input_class_t *this = (vdr_input_class_t *)this_gen;
>+
>+ free(this);
>+}
>+
>+static char **vdr_class_get_autoplay_list(input_class_t *this_gen,
>+ int *num_files)
>+{
>+ vdr_input_class_t *class = (vdr_input_class_t *)this_gen;
>+
>+ *num_files = 1;
>+ return class->mrls;
>+}
>+
>+static void *init_class(xine_t *xine, void *data)
>+{
>+ vdr_input_class_t *this;
>+
>+ lprintf("init_class\n");
>+
>+ this = (vdr_input_class_t *)xine_xmalloc(sizeof (vdr_input_class_t));
>+
>+ this->xine = xine;
>+
>+ this->mrls[ 0 ] = "vdr:" VDR_ABS_FIFO_DIR "/stream#demux:mpeg_pes";
>+ this->mrls[ 1 ] = 0;
>+
>+ this->input_class.get_instance = vdr_class_get_instance;
>+ this->input_class.get_identifier = vdr_class_get_identifier;
>+ this->input_class.get_description = vdr_class_get_description;
>+ this->input_class.get_dir = NULL;
>+ this->input_class.get_autoplay_list = vdr_class_get_autoplay_list;
>+ this->input_class.dispose = vdr_class_dispose;
>+ this->input_class.eject_media = NULL;
>+
>+ return this;
>+}
>+
>+/*
>+ * exported plugin catalog entry
>+ */
>+
>+plugin_info_t xine_plugin_info[] =
>+{
>+ /* type, API, "name", version, special_info, init_function */
>+ { PLUGIN_INPUT, 17, "VDR", XINE_VERSION_CODE, NULL, init_class },
>+ { PLUGIN_NONE, 0, "", 0, NULL, NULL }
>+};
>diff -ruN xine-lib-1.1.1.orig/src/vdr/input_vdr.h xine-lib-1.1.1/src/vdr/input_vdr.h
>--- xine-lib-1.1.1.orig/src/vdr/input_vdr.h 1970-01-01 01:00:00.000000000 +0100
>+++ xine-lib-1.1.1/src/vdr/input_vdr.h 2006-01-02 20:15:55.000000000 +0100
>@@ -0,0 +1,548 @@
>+
>+#ifndef __INPUT_VDR_H
>+#define __INPUT_VDR_H
>+
>+
>+
>+enum funcs
>+{
>+ func_unknown = -1
>+ , func_nop
>+ , func_osd_new
>+ , func_osd_free
>+ , func_osd_show
>+ , func_osd_hide
>+ , func_osd_set_position
>+ , func_osd_draw_bitmap
>+ , func_set_color
>+ , func_clear
>+ , func_mute
>+ , func_set_volume
>+ , func_set_speed
>+ , func_set_prebuffer
>+ , func_metronom
>+ , func_start
>+ , func_wait
>+ , func_setup
>+ , func_grab_image
>+ , func_get_pts
>+ , func_flush
>+ , func_first_frame
>+ , func_still_frame
>+ , func_video_size
>+ , func_set_video_window
>+ , func_osd_flush
>+ , func_play_external
>+ , func_key
>+ , func_frame_size
>+ , func_reset_audio
>+ , func_select_audio
>+ , func_trick_speed_mode
>+};
>+
>+enum keys
>+{
>+ key_none,
>+ key_up,
>+ key_down,
>+ key_menu,
>+ key_ok,
>+ key_back,
>+ key_left,
>+ key_right,
>+ key_red,
>+ key_green,
>+ key_yellow,
>+ key_blue,
>+ key_0,
>+ key_1,
>+ key_2,
>+ key_3,
>+ key_4,
>+ key_5,
>+ key_6,
>+ key_7,
>+ key_8,
>+ key_9,
>+ key_play,
>+ key_pause,
>+ key_stop,
>+ key_record,
>+ key_fast_fwd,
>+ key_fast_rew,
>+ key_power,
>+ key_channel_plus,
>+ key_channel_minus,
>+ key_volume_plus,
>+ key_volume_minus,
>+ key_mute,
>+ key_schedule,
>+ key_channels,
>+ key_timers,
>+ key_recordings,
>+ key_setup,
>+ key_commands,
>+ key_user1,
>+ key_user2,
>+ key_user3,
>+ key_user4,
>+ key_user5,
>+ key_user6,
>+ key_user7,
>+ key_user8,
>+ key_user9,
>+ key_audio,
>+};
>+
>+
>+
>+typedef struct __attribute__((packed)) data_header_s
>+{
>+ uint32_t func:8;
>+ uint32_t len:24;
>+}
>+data_header_t;
>+
>+
>+
>+typedef data_header_t result_header_t;
>+typedef data_header_t event_header_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_nop_s
>+{
>+ data_header_t header;
>+}
>+data_nop_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_osd_new_s
>+{
>+ data_header_t header;
>+
>+ uint8_t window;
>+ int16_t x;
>+ int16_t y;
>+ uint16_t width;
>+ uint16_t height;
>+}
>+data_osd_new_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_osd_free_s
>+{
>+ data_header_t header;
>+
>+ uint8_t window;
>+}
>+data_osd_free_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_osd_show_s
>+{
>+ data_header_t header;
>+
>+ uint8_t window;
>+}
>+data_osd_show_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_osd_hide_s
>+{
>+ data_header_t header;
>+
>+ uint8_t window;
>+}
>+data_osd_hide_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_osd_flush_s
>+{
>+ data_header_t header;
>+}
>+data_osd_flush_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_play_external_s
>+{
>+ data_header_t header;
>+}
>+data_play_external_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_osd_set_position_s
>+{
>+ data_header_t header;
>+
>+ uint8_t window;
>+ int16_t x;
>+ int16_t y;
>+}
>+data_osd_set_position_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_osd_draw_bitmap_s
>+{
>+ data_header_t header;
>+
>+ uint8_t window;
>+ int16_t x;
>+ int16_t y;
>+ uint16_t width;
>+ uint16_t height;
>+}
>+data_osd_draw_bitmap_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_set_color_s
>+{
>+ data_header_t header;
>+
>+ uint8_t window;
>+ uint8_t index;
>+ uint8_t num;
>+}
>+data_set_color_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_flush_s
>+{
>+ data_header_t header;
>+
>+ int32_t ms_timeout;
>+ uint8_t just_wait;
>+}
>+data_flush_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) result_flush_s
>+{
>+ result_header_t header;
>+
>+ uint8_t timed_out;
>+}
>+result_flush_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_clear_s
>+{
>+ data_header_t header;
>+
>+ int32_t n;
>+}
>+data_clear_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_mute_s
>+{
>+ data_header_t header;
>+
>+ uint8_t mute;
>+}
>+data_mute_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_set_volume_s
>+{
>+ data_header_t header;
>+
>+ uint8_t volume;
>+}
>+data_set_volume_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_set_speed_s
>+{
>+ data_header_t header;
>+
>+ int32_t speed;
>+}
>+data_set_speed_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_set_prebuffer_s
>+{
>+ data_header_t header;
>+
>+ uint32_t prebuffer;
>+}
>+data_set_prebuffer_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_metronom_s
>+{
>+ data_header_t header;
>+
>+ int64_t pts;
>+ uint32_t flags;
>+}
>+data_metronom_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_start_s
>+{
>+ data_header_t header;
>+}
>+data_start_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_wait_s
>+{
>+ data_header_t header;
>+
>+ uint8_t data[ 64 * 1024 - sizeof (data_header_t) ];
>+}
>+data_wait_t;
>+
>+
>+
>+#define INPUT_VDR_MUTE_IGNORE 0
>+#define INPUT_VDR_MUTE_EXECUTE 1
>+#define INPUT_VDR_MUTE_SIMULATE 2
>+
>+typedef struct __attribute__((packed)) data_setup_s
>+{
>+ data_header_t header;
>+
>+ uint8_t osd_unscaled_blending;
>+ uint8_t dont_change_xine_volume;
>+ uint8_t mute_mode;
>+}
>+data_setup_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_first_frame_s
>+{
>+ data_header_t header;
>+}
>+data_first_frame_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_still_frame_s
>+{
>+ data_header_t header;
>+}
>+data_still_frame_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_set_video_window_s
>+{
>+ data_header_t header;
>+
>+ uint32_t x;
>+ uint32_t y;
>+ uint32_t w;
>+ uint32_t h;
>+ uint32_t w_ref;
>+ uint32_t h_ref;
>+}
>+data_set_video_window_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_grab_image_s
>+{
>+ data_header_t header;
>+}
>+data_grab_image_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) result_grab_image_s
>+{
>+ result_header_t header;
>+
>+ int32_t width;
>+ int32_t height;
>+ int32_t ratio;
>+ int32_t format;
>+}
>+result_grab_image_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_get_pts_s
>+{
>+ data_header_t header;
>+}
>+data_get_pts_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) result_get_pts_s
>+{
>+ result_header_t header;
>+
>+ int64_t pts;
>+}
>+result_get_pts_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_video_size_s
>+{
>+ data_header_t header;
>+}
>+data_video_size_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) result_video_size_s
>+{
>+ result_header_t header;
>+
>+ int32_t left;
>+ int32_t top;
>+ int32_t width;
>+ int32_t height;
>+ int32_t ratio;
>+}
>+result_video_size_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_reset_audio_s
>+{
>+ data_header_t header;
>+}
>+data_reset_audio_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) event_key_s
>+{
>+ event_header_t header;
>+
>+ uint32_t key;
>+}
>+event_key_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) event_frame_size_s
>+{
>+ event_header_t header;
>+
>+ int32_t left;
>+ int32_t top;
>+ int32_t width;
>+ int32_t height;
>+}
>+event_frame_size_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) event_play_external_s
>+{
>+ event_header_t header;
>+
>+ uint32_t key;
>+}
>+event_play_external_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_select_audio_s
>+{
>+ data_header_t header;
>+
>+ uint8_t channels;
>+}
>+data_select_audio_t;
>+
>+
>+
>+typedef struct __attribute__((packed)) data_trick_speed_mode_s
>+{
>+ data_header_t header;
>+
>+ uint8_t on;
>+}
>+data_trick_speed_mode_t;
>+
>+
>+
>+typedef union __attribute__((packed)) data_union_u
>+{
>+ data_header_t header;
>+ data_nop_t nop;
>+ data_osd_new_t osd_new;
>+ data_osd_free_t osd_free;
>+ data_osd_show_t osd_show;
>+ data_osd_hide_t osd_hide;
>+ data_osd_set_position_t osd_set_position;
>+ data_osd_draw_bitmap_t osd_draw_bitmap;
>+ data_set_color_t set_color;
>+ data_flush_t flush;
>+ data_clear_t clear;
>+ data_mute_t mute;
>+ data_set_volume_t set_volume;
>+ data_set_speed_t set_speed;
>+ data_set_prebuffer_t set_prebuffer;
>+ data_metronom_t metronom;
>+ data_start_t start;
>+ data_wait_t wait;
>+ data_setup_t setup;
>+ data_grab_image_t grab_image;
>+ data_get_pts_t get_pts;
>+ data_first_frame_t first_frame;
>+ data_still_frame_t still_frame;
>+ data_video_size_t video_size;
>+ data_set_video_window_t set_video_window;
>+ data_osd_flush_t osd_flush;
>+ data_play_external_t play_external;
>+ data_reset_audio_t reset_audio;
>+ data_select_audio_t select_audio;
>+ data_trick_speed_mode_t trick_speed_mode;
>+}
>+data_union_t;
>+
>+
>+
>+typedef union __attribute__((packed)) result_union_u
>+{
>+ result_header_t header;
>+ result_grab_image_t grab_image;
>+ result_get_pts_t get_pts;
>+ result_flush_t flush;
>+ result_video_size_t video_size;
>+}
>+result_union_t;
>+
>+
>+
>+typedef union __attribute__((packed)) event_union_u
>+{
>+ event_header_t header;
>+ event_key_t key;
>+ event_frame_size_t frame_size;
>+ event_play_external_t play_external;
>+}
>+event_union_t;
>+
>+
>+
>+#endif /* __INPUT_VDR_H */
>diff -ruN xine-lib-1.1.1.orig/src/vdr/Makefile.am xine-lib-1.1.1/src/vdr/Makefile.am
>--- xine-lib-1.1.1.orig/src/vdr/Makefile.am 1970-01-01 01:00:00.000000000 +0100
>+++ xine-lib-1.1.1/src/vdr/Makefile.am 2006-01-02 20:11:39.000000000 +0100
>@@ -0,0 +1,29 @@
>+include $(top_srcdir)/misc/Makefile.common
>+
>+
>+
>+libdir = $(XINE_PLUGINDIR)
>+
>+AM_CFLAGS = -D_LARGEFILE64_SOURCE
>+
>+lib_LTLIBRARIES = \
>+ xineplug_inp_vdr.la
>+
>+xineplug_inp_vdr_la_SOURCES = input_vdr.c
>+xineplug_inp_vdr_la_LIBADD = $(XINE_LIB)
>+xineplug_inp_vdr_la_LDFLAGS = -avoid-version -module @XINE_PLUGIN_MIN_SYMS@
>+
>+include_HEADERS = input_vdr.h
>+
>+
>+
>+postlibdir = $(XINE_PLUGINDIR)/post
>+
>+postlib_LTLIBRARIES = \
>+ xineplug_post_vdr.la
>+
>+xineplug_post_vdr_la_SOURCES = post_vdr.c post_vdr_video.c post_vdr_audio.c
>+xineplug_post_vdr_la_LIBADD = $(XINE_LIB)
>+xineplug_post_vdr_la_LDFLAGS = -avoid-version -module @XINE_PLUGIN_MIN_SYMS@
>+
>+noinst_HEADERS = post_vdr.h
>diff -ruN xine-lib-1.1.1.orig/src/vdr/post_vdr_audio.c xine-lib-1.1.1/src/vdr/post_vdr_audio.c
>--- xine-lib-1.1.1.orig/src/vdr/post_vdr_audio.c 1970-01-01 01:00:00.000000000 +0100
>+++ xine-lib-1.1.1/src/vdr/post_vdr_audio.c 2006-01-02 20:17:42.000000000 +0100
>@@ -0,0 +1,287 @@
>+/*
>+ * 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: vdr.c,v 1.20 2004/04/17 19:54:32 mroi Exp $
>+ */
>+
>+/*
>+ * select audio channel plugin for VDR
>+ */
>+
>+#define LOG_MODULE "vdr_audio"
>+#define LOG_VERBOSE
>+/*
>+#define LOG
>+*/
>+
>+#include "xine_internal.h"
>+#include "post.h"
>+#include "post_vdr.h"
>+
>+
>+
>+typedef struct vdr_audio_post_plugin_s
>+{
>+ post_plugin_t post_plugin;
>+
>+ xine_event_queue_t *event_queue;
>+ xine_stream_t *vdr_stream;
>+
>+ uint8_t audio_channels;
>+ int num_channels;
>+
>+}
>+vdr_audio_post_plugin_t;
>+
>+
>+static void vdr_audio_select_audio(vdr_audio_post_plugin_t *this, uint8_t channels)
>+{
>+ this->audio_channels = channels;
>+}
>+
>+
>+/* plugin class functions */
>+static post_plugin_t *vdr_audio_open_plugin(post_class_t *class_gen, int inputs,
>+ xine_audio_port_t **audio_target,
>+ xine_video_port_t **video_target);
>+static char *vdr_audio_get_identifier(post_class_t *class_gen);
>+static char *vdr_audio_get_description(post_class_t *class_gen);
>+static void vdr_audio_class_dispose(post_class_t *class_gen);
>+
>+/* plugin instance functions */
>+static void vdr_audio_dispose(post_plugin_t *this_gen);
>+
>+/* replaced ao_port functions */
>+static int vdr_audio_port_open(xine_audio_port_t *port_gen, xine_stream_t *stream,
>+ uint32_t bits, uint32_t rate, int mode);
>+static void vdr_audio_port_put_buffer(xine_audio_port_t *port_gen, audio_buffer_t *buf, xine_stream_t *stream);
>+
>+
>+
>+void *vdr_audio_init_plugin(xine_t *xine, void *data)
>+{
>+ post_class_t *class = (post_class_t *)malloc(sizeof (post_class_t));
>+
>+ if (!class)
>+ return NULL;
>+
>+ class->open_plugin = vdr_audio_open_plugin;
>+ class->get_identifier = vdr_audio_get_identifier;
>+ class->get_description = vdr_audio_get_description;
>+ class->dispose = vdr_audio_class_dispose;
>+
>+ return class;
>+}
>+
>+static post_plugin_t *vdr_audio_open_plugin(post_class_t *class_gen, int inputs,
>+ xine_audio_port_t **audio_target,
>+ xine_video_port_t **video_target)
>+{
>+ vdr_audio_post_plugin_t *this = (vdr_audio_post_plugin_t *)xine_xmalloc(sizeof (vdr_audio_post_plugin_t));
>+ post_in_t *input;
>+ post_out_t *output;
>+ post_audio_port_t *port;
>+/*
>+fprintf(stderr, "~~~~~~~~~~ vdr open plugin\n");
>+*/
>+ if (!this || !audio_target || !audio_target[ 0 ])
>+ {
>+ free(this);
>+ return NULL;
>+ }
>+
>+ _x_post_init(&this->post_plugin, 1, 0);
>+ this->post_plugin.dispose = vdr_audio_dispose;
>+
>+ port = _x_post_intercept_audio_port(&this->post_plugin, audio_target[ 0 ], &input, &output);
>+ port->new_port.open = vdr_audio_port_open;
>+ port->new_port.put_buffer = vdr_audio_port_put_buffer;
>+
>+ this->post_plugin.xine_post.audio_input[ 0 ] = &port->new_port;
>+
>+
>+
>+ this->audio_channels = 0;
>+
>+ return &this->post_plugin;
>+}
>+
>+static char *vdr_audio_get_identifier(post_class_t *class_gen)
>+{
>+ return "vdr_audio";
>+}
>+
>+static char *vdr_audio_get_description(post_class_t *class_gen)
>+{
>+ return "modifies every audio frame as requested by VDR";
>+}
>+
>+static void vdr_audio_class_dispose(post_class_t *class_gen)
>+{
>+ free(class_gen);
>+}
>+
>+
>+static void vdr_audio_dispose(post_plugin_t *this_gen)
>+{
>+/*
>+fprintf(stderr, "~~~~~~~~~~ vdr dispose\n");
>+*/
>+ if (_x_post_dispose(this_gen))
>+ {
>+ vdr_audio_post_plugin_t *this = (vdr_audio_post_plugin_t *)this_gen;
>+
>+ if (this->vdr_stream)
>+ xine_event_dispose_queue(this->event_queue);
>+
>+ free(this_gen);
>+ }
>+}
>+
>+static int vdr_audio_port_open(xine_audio_port_t *port_gen, xine_stream_t *stream,
>+ uint32_t bits, uint32_t rate, int mode) {
>+
>+ post_audio_port_t *port = (post_audio_port_t *)port_gen;
>+ vdr_audio_post_plugin_t *this = (vdr_audio_post_plugin_t *)port->post;
>+
>+ _x_post_rewire(&this->post_plugin);
>+ _x_post_inc_usage(port);
>+/*
>+fprintf(stderr, "~~~~~~~~~~ vdr port open\n");
>+*/
>+ port->stream = stream;
>+ port->bits = bits;
>+ port->rate = rate;
>+ port->mode = mode;
>+
>+ this->num_channels = _x_ao_mode2channels(mode);
>+
>+ return port->original_port->open(port->original_port, stream, bits, rate, mode );
>+}
>+
>+
>+static void vdr_audio_port_put_buffer(xine_audio_port_t *port_gen, audio_buffer_t *buf, xine_stream_t *stream)
>+{
>+ post_audio_port_t *port = (post_audio_port_t *)port_gen;
>+ vdr_audio_post_plugin_t *this = (vdr_audio_post_plugin_t *)port->post;
>+ xine_event_t *event;
>+/*
>+fprintf(stderr, "~~~~~~ vdr_audio\n");
>+*/
>+ if (this->vdr_stream
>+ && !_x_continue_stream_processing(this->vdr_stream))
>+ {
>+ this->vdr_stream = 0;
>+
>+ xine_event_dispose_queue(this->event_queue);
>+ this->event_queue = 0;
>+
>+ this->audio_channels = 0;
>+ }
>+
>+ if (!this->vdr_stream
>+ && vdr_is_vdr_stream(stream))
>+ {
>+ this->event_queue = xine_event_new_queue(stream);
>+ if (this->event_queue)
>+ {
>+ this->vdr_stream = stream;
>+
>+ {
>+ xine_event_t event;
>+
>+ event.type = XINE_EVENT_VDR_PLUGINSTARTED;
>+ event.data = 0;
>+ event.data_length = 1; /* vdr_audio */
>+
>+ xine_event_send(this->vdr_stream, &event);
>+ }
>+ }
>+ }
>+
>+ if (this->event_queue)
>+ {
>+ while ((event = xine_event_get(this->event_queue)))
>+ {
>+ if (event->type == XINE_EVENT_VDR_SELECTAUDIO)
>+ {
>+ vdr_select_audio_data_t *data = (vdr_select_audio_data_t *)event->data;
>+
>+ vdr_audio_select_audio(this, data->channels);
>+ }
>+
>+ xine_event_free(event);
>+ }
>+ }
>+
>+ if (this->num_channels == 2
>+ && this->audio_channels != 0
>+ && this->audio_channels != 3)
>+ {
>+ audio_buffer_t *vdr_buf = port->original_port->get_buffer(port->original_port);
>+ vdr_buf->num_frames = buf->num_frames;
>+ vdr_buf->vpts = buf->vpts;
>+ vdr_buf->frame_header_count = buf->frame_header_count;
>+ vdr_buf->first_access_unit = buf->first_access_unit;
>+ /* FIXME: The audio buffer should contain this info.
>+ * We should not have to get it from the open call.
>+ */
>+ vdr_buf->format.bits = buf->format.bits;
>+ vdr_buf->format.rate = buf->format.rate;
>+ vdr_buf->format.mode = buf->format.mode;
>+ _x_extra_info_merge(vdr_buf->extra_info, buf->extra_info);
>+
>+ {
>+ int step = buf->format.bits / 8;
>+ uint8_t *src = (uint8_t *)buf->mem;
>+ uint8_t *dst = (uint8_t *)vdr_buf->mem;
>+
>+ if (this->audio_channels == 2)
>+ src += step;
>+/*
>+ fprintf(stderr, "~~~~~~~~~~ vdr port put buffer: channels: %d, %d\n"
>+ , this->audio_channels
>+ , buf->format.bits);
>+*/
>+ int i, k;
>+ for (i = 0; i < buf->num_frames; i++)
>+ {
>+ for (k = 0; k < step; k++)
>+ *dst++ = *src++;
>+
>+ src -= step;
>+
>+ for (k = 0; k < step; k++)
>+ *dst++ = *src++;
>+
>+ src += step;
>+ }
>+ }
>+
>+ /* pass data to original port */
>+ port->original_port->put_buffer(port->original_port, vdr_buf, stream);
>+
>+ /* free data from origial buffer */
>+ buf->num_frames = 0; /* UNDOCUMENTED, but hey, it works! Force old audio_out buffer free. */
>+ }
>+
>+ port->original_port->put_buffer(port->original_port, buf, stream);
>+
>+ return;
>+}
>diff -ruN xine-lib-1.1.1.orig/src/vdr/post_vdr.c xine-lib-1.1.1/src/vdr/post_vdr.c
>--- xine-lib-1.1.1.orig/src/vdr/post_vdr.c 1970-01-01 01:00:00.000000000 +0100
>+++ xine-lib-1.1.1/src/vdr/post_vdr.c 2006-01-02 20:16:44.000000000 +0100
>@@ -0,0 +1,43 @@
>+/*
>+ * 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: vdr.c,v 1.20 2004/04/17 19:54:32 mroi Exp $
>+ */
>+
>+/*
>+ * plugins for VDR
>+ */
>+
>+#include "xine_internal.h"
>+#include "post.h"
>+#include "post_vdr.h"
>+
>+
>+
>+static post_info_t vdr_video_special_info = { XINE_POST_TYPE_VIDEO_FILTER };
>+static post_info_t vdr_audio_special_info = { XINE_POST_TYPE_AUDIO_FILTER };
>+
>+plugin_info_t xine_plugin_info[] =
>+{
>+ /* type, API, "name", version, special_info, init_function */
>+ { PLUGIN_POST, 9, "vdr" , XINE_VERSION_CODE, &vdr_video_special_info, &vdr_video_init_plugin },
>+ { PLUGIN_POST, 9, "vdr_video", XINE_VERSION_CODE, &vdr_video_special_info, &vdr_video_init_plugin },
>+ { PLUGIN_POST, 9, "vdr_audio", XINE_VERSION_CODE, &vdr_audio_special_info, &vdr_audio_init_plugin },
>+ { PLUGIN_NONE, 0, "", 0, NULL, NULL }
>+};
>diff -ruN xine-lib-1.1.1.orig/src/vdr/post_vdr.h xine-lib-1.1.1/src/vdr/post_vdr.h
>--- xine-lib-1.1.1.orig/src/vdr/post_vdr.h 1970-01-01 01:00:00.000000000 +0100
>+++ xine-lib-1.1.1/src/vdr/post_vdr.h 2006-01-02 20:17:08.000000000 +0100
>@@ -0,0 +1,70 @@
>+
>+#ifndef __POST_VDR_H
>+#define __POST_VDR_H
>+
>+
>+
>+typedef struct vdr_set_video_window_data_s {
>+ int32_t x;
>+ int32_t y;
>+ int32_t w;
>+ int32_t h;
>+ int32_t w_ref;
>+ int32_t h_ref;
>+
>+} vdr_set_video_window_data_t;
>+
>+
>+
>+typedef struct vdr_frame_size_changed_data_s {
>+ int32_t x;
>+ int32_t y;
>+ int32_t w;
>+ int32_t h;
>+
>+} vdr_frame_size_changed_data_t;
>+
>+
>+
>+typedef struct vdr_select_audio_data_s {
>+ uint8_t channels;
>+
>+} vdr_select_audio_data_t;
>+
>+
>+
>+inline static int vdr_is_vdr_stream(xine_stream_t *stream)
>+{
>+ if (!stream
>+ || !stream->input_plugin
>+ || !stream->input_plugin->input_class)
>+ {
>+ return 0;
>+ }
>+
>+ {
>+ input_class_t *input_class = stream->input_plugin->input_class;
>+
>+ if (input_class->get_identifier)
>+ {
>+ const char *identifier = input_class->get_identifier(input_class);
>+ if (identifier
>+ && 0 == strcmp(identifier, "VDR"))
>+ {
>+ return 1;
>+ }
>+ }
>+ }
>+
>+ return 0;
>+}
>+
>+
>+
>+/* plugin class initialization function */
>+void *vdr_video_init_plugin(xine_t *xine, void *);
>+void *vdr_audio_init_plugin(xine_t *xine, void *);
>+
>+
>+
>+#endif /* __POST_VDR_H */
>diff -ruN xine-lib-1.1.1.orig/src/vdr/post_vdr_video.c xine-lib-1.1.1/src/vdr/post_vdr_video.c
>--- xine-lib-1.1.1.orig/src/vdr/post_vdr_video.c 1970-01-01 01:00:00.000000000 +0100
>+++ xine-lib-1.1.1/src/vdr/post_vdr_video.c 2006-01-02 20:18:27.000000000 +0100
>@@ -0,0 +1,485 @@
>+/*
>+ * 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: vdr.c,v 1.20 2004/04/17 19:54:32 mroi Exp $
>+ */
>+
>+/*
>+ * frame scaler plugin for VDR
>+ */
>+
>+#define LOG_MODULE "vdr_video"
>+#define LOG_VERBOSE
>+/*
>+#define LOG
>+*/
>+
>+#include "xine_internal.h"
>+#include "post.h"
>+#include "post_vdr.h"
>+
>+
>+
>+typedef struct vdr_video_post_plugin_s
>+{
>+ post_plugin_t post_plugin;
>+
>+ xine_event_queue_t *event_queue;
>+ xine_stream_t *vdr_stream;
>+
>+ int8_t trick_speed_mode;
>+ int8_t enabled;
>+
>+ int32_t x;
>+ int32_t y;
>+ int32_t w;
>+ int32_t h;
>+ int32_t w_ref;
>+ int32_t h_ref;
>+
>+ int32_t old_frame_left;
>+ int32_t old_frame_top;
>+ int32_t old_frame_width;
>+ int32_t old_frame_height;
>+
>+}
>+vdr_video_post_plugin_t;
>+
>+
>+static void vdr_video_set_video_window(vdr_video_post_plugin_t *this, int32_t x, int32_t y, int32_t w, int32_t h, int32_t w_ref, int32_t h_ref)
>+{
>+ this->enabled = 0;
>+
>+ this->x = x;
>+ this->y = y;
>+ this->w = w;
>+ this->h = h;
>+ this->w_ref = w_ref;
>+ this->h_ref = h_ref;
>+
>+ if (w != w_ref || h != h_ref)
>+ this->enabled = 1;
>+}
>+
>+
>+/* plugin class functions */
>+static post_plugin_t *vdr_video_open_plugin(post_class_t *class_gen, int inputs,
>+ xine_audio_port_t **audio_target,
>+ xine_video_port_t **video_target);
>+static char *vdr_video_get_identifier(post_class_t *class_gen);
>+static char *vdr_video_get_description(post_class_t *class_gen);
>+static void vdr_video_class_dispose(post_class_t *class_gen);
>+
>+/* plugin instance functions */
>+static void vdr_video_dispose(post_plugin_t *this_gen);
>+
>+/* frame intercept check */
>+static int vdr_video_intercept_frame(post_video_port_t *port, vo_frame_t *frame);
>+
>+/* replaced vo_frame functions */
>+static int vdr_video_draw(vo_frame_t *frame, xine_stream_t *stream);
>+
>+
>+void *vdr_video_init_plugin(xine_t *xine, void *data)
>+{
>+ post_class_t *class = (post_class_t *)malloc(sizeof (post_class_t));
>+
>+ if (!class)
>+ return NULL;
>+
>+ class->open_plugin = vdr_video_open_plugin;
>+ class->get_identifier = vdr_video_get_identifier;
>+ class->get_description = vdr_video_get_description;
>+ class->dispose = vdr_video_class_dispose;
>+
>+ return class;
>+}
>+
>+static post_plugin_t *vdr_video_open_plugin(post_class_t *class_gen, int inputs,
>+ xine_audio_port_t **audio_target,
>+ xine_video_port_t **video_target)
>+{
>+ vdr_video_post_plugin_t *this = (vdr_video_post_plugin_t *)xine_xmalloc(sizeof (vdr_video_post_plugin_t));
>+ post_in_t *input;
>+ post_out_t *output;
>+ post_video_port_t *port;
>+
>+ if (!this || !video_target || !video_target[ 0 ])
>+ {
>+ free(this);
>+ return NULL;
>+ }
>+
>+ _x_post_init(&this->post_plugin, 0, 1);
>+ this->post_plugin.dispose = vdr_video_dispose;
>+
>+ port = _x_post_intercept_video_port(&this->post_plugin, video_target[ 0 ], &input, &output);
>+ port->intercept_frame = vdr_video_intercept_frame;
>+ port->new_frame->draw = vdr_video_draw;
>+ this->post_plugin.xine_post.video_input[ 0 ] = &port->new_port;
>+
>+
>+
>+ this->enabled = 0;
>+ this->vdr_stream = 0;
>+ this->event_queue = 0;
>+ this->old_frame_left = 0;
>+ this->old_frame_top = 0;
>+ this->old_frame_width = 0;
>+ this->old_frame_height = 0;
>+ this->trick_speed_mode = 0;
>+
>+ return &this->post_plugin;
>+}
>+
>+static char *vdr_video_get_identifier(post_class_t *class_gen)
>+{
>+ return "vdr";
>+}
>+
>+static char *vdr_video_get_description(post_class_t *class_gen)
>+{
>+ return "modifies every video frame as requested by VDR";
>+}
>+
>+static void vdr_video_class_dispose(post_class_t *class_gen)
>+{
>+ free(class_gen);
>+}
>+
>+
>+static void vdr_video_dispose(post_plugin_t *this_gen)
>+{
>+ if (_x_post_dispose(this_gen))
>+ {
>+ vdr_video_post_plugin_t *this = (vdr_video_post_plugin_t *)this_gen;
>+
>+ if (this->vdr_stream)
>+ {
>+ xine_event_t event;
>+ vdr_frame_size_changed_data_t event_data;
>+
>+ event_data.x = 0;
>+ event_data.y = 0;
>+ event_data.w = 0;
>+ event_data.h = 0;
>+
>+ event.type = XINE_EVENT_VDR_FRAMESIZECHANGED;
>+ event.data = &event_data;
>+ event.data_length = sizeof (event_data);
>+
>+ xine_event_send(this->vdr_stream, &event);
>+
>+ xine_event_dispose_queue(this->event_queue);
>+ }
>+
>+ free(this_gen);
>+ }
>+}
>+
>+
>+static int vdr_video_intercept_frame(post_video_port_t *port, vo_frame_t *frame)
>+{
>+ return (frame->format == XINE_IMGFMT_YUY2
>+ || frame->format == XINE_IMGFMT_YV12);
>+}
>+
>+
>+static inline void vdr_video_scale(uint8_t *src, uint8_t *dst, int y_inc, int x_inc, int w_dst, int h_dst, int x, int y, int w, int h, int w_ref, int h_ref, int init)
>+{
>+ int x0 = x * w_dst / w_ref;
>+ int y0 = y * h_dst / h_ref;
>+
>+ int x1 = ((x + w) * w_dst - 1 + w_ref) / w_ref;
>+ int y1 = ((y + h) * h_dst - 1 + h_ref) / h_ref;
>+
>+ int dx = x1 - x0;
>+ int dy = y1 - y0;
>+
>+ int yy, xx;
>+
>+ int dy2 = dy + dy;
>+ int h_dst2 = h_dst + h_dst;
>+ int y_eps = h_dst - dy2;
>+
>+ int dx2 = dx + dx;
>+ int w_dst2 = w_dst + w_dst;
>+ int x_eps0 = w_dst - dx2;
>+
>+ for (yy = 0; yy < y0; yy++)
>+ {
>+ uint8_t *dst0 = dst;
>+
>+ for (xx = 0; xx < w_dst; xx++)
>+ {
>+ *dst0 = init;
>+ dst0 += x_inc;
>+ }
>+
>+ dst += y_inc;
>+ }
>+
>+ for (yy = y0; yy < y1; yy++)
>+ {
>+ uint8_t *dst0 = dst;
>+ uint8_t *src0 = src;
>+
>+ int x_eps = x_eps0;
>+
>+ for (xx = 0; xx < x0; xx++)
>+ {
>+ *dst0 = init;
>+ dst0 += x_inc;
>+ }
>+
>+ for (xx = x0; xx < x1; xx++)
>+ {
>+ *dst0 = *src0;
>+ dst0 += x_inc;
>+
>+ x_eps += w_dst2;
>+ while (x_eps >= 0)
>+ {
>+ src0 += x_inc;
>+ x_eps -= dx2;
>+ }
>+ }
>+
>+ for (xx = x1; xx < w_dst; xx++)
>+ {
>+ *dst0 = init;
>+ dst0 += x_inc;
>+ }
>+
>+ dst += y_inc;
>+
>+ y_eps += h_dst2;
>+ while (y_eps >= 0)
>+ {
>+ src += y_inc;
>+ y_eps -= dy2;
>+ }
>+ }
>+
>+ for (yy = y1; yy < h_dst; yy++)
>+ {
>+ uint8_t *dst0 = dst;
>+
>+ for (xx = 0; xx < w_dst; xx++)
>+ {
>+ *dst0 = init;
>+ dst0 += x_inc;
>+ }
>+
>+ dst += y_inc;
>+ }
>+}
>+
>+static void vdr_video_scale_YUY2(vdr_video_post_plugin_t *this, vo_frame_t *src, vo_frame_t *dst)
>+{
>+ int w = dst->width - dst->crop_left - dst->crop_right;
>+ int h = dst->height - dst->crop_top - dst->crop_bottom;
>+ int offset;
>+
>+ if (w < 0)
>+ w = 0;
>+
>+ if (h < 0)
>+ h = 0;
>+
>+ offset = dst->pitches[ 0 ] * dst->crop_top + 2 * dst->crop_left;
>+ vdr_video_scale(&src->base[ 0 ][ 0 ] + offset, &dst->base[ 0 ][ 0 ] + offset, dst->pitches[ 0 ], 2, w , h, this->x, this->y, this->w, this->h, this->w_ref, this->h_ref, 0x00);
>+ offset = dst->pitches[ 0 ] * dst->crop_top + 4 * ((dst->crop_left + 1) / 2);
>+ vdr_video_scale(&src->base[ 0 ][ 1 ] + offset, &dst->base[ 0 ][ 1 ] + offset, dst->pitches[ 0 ], 4, (w + 1) / 2, h, this->x, this->y, this->w, this->h, this->w_ref, this->h_ref, 0x80);
>+ offset = dst->pitches[ 0 ] * dst->crop_top + 4 * ((dst->crop_left + 1) / 2);
>+ vdr_video_scale(&src->base[ 0 ][ 3 ] + offset, &dst->base[ 0 ][ 3 ] + offset, dst->pitches[ 0 ], 4, (w + 1) / 2, h, this->x, this->y, this->w, this->h, this->w_ref, this->h_ref, 0x80);
>+}
>+
>+static void vdr_video_scale_YV12(vdr_video_post_plugin_t *this, vo_frame_t *src, vo_frame_t *dst)
>+{
>+ int w = dst->width - dst->crop_left - dst->crop_right;
>+ int h = dst->height - dst->crop_top - dst->crop_bottom;
>+ int offset;
>+
>+ if (w < 0)
>+ w = 0;
>+
>+ if (h < 0)
>+ h = 0;
>+
>+ offset = dst->pitches[ 0 ] * dst->crop_top + 1 * dst->crop_left;
>+ vdr_video_scale(&src->base[ 0 ][ 0 ] + offset, &dst->base[ 0 ][ 0 ] + offset, dst->pitches[ 0 ], 1, w , h , this->x, this->y, this->w, this->h, this->w_ref, this->h_ref, 0x00);
>+ offset = dst->pitches[ 1 ] * ((dst->crop_top + 1) / 2) + 1 * ((dst->crop_left + 1) / 2);
>+ vdr_video_scale(&src->base[ 1 ][ 0 ] + offset, &dst->base[ 1 ][ 0 ] + offset, dst->pitches[ 1 ], 1, (w + 1) / 2, (h + 1) / 2, this->x, this->y, this->w, this->h, this->w_ref, this->h_ref, 0x80);
>+ offset = dst->pitches[ 2 ] * ((dst->crop_top + 1) / 2) + 1 * ((dst->crop_left + 1) / 2);
>+ vdr_video_scale(&src->base[ 2 ][ 0 ] + offset, &dst->base[ 2 ][ 0 ] + offset, dst->pitches[ 2 ], 1, (w + 1) / 2, (h + 1) / 2, this->x, this->y, this->w, this->h, this->w_ref, this->h_ref, 0x80);
>+}
>+
>+
>+static int vdr_video_draw(vo_frame_t *frame, xine_stream_t *stream)
>+{
>+ post_video_port_t *port = (post_video_port_t *)frame->port;
>+ vdr_video_post_plugin_t *this = (vdr_video_post_plugin_t *)port->post;
>+ vo_frame_t *vdr_frame;
>+ xine_event_t *event;
>+ int skip;
>+
>+ if (this->vdr_stream
>+ && !_x_continue_stream_processing(this->vdr_stream))
>+ {
>+ this->vdr_stream = 0;
>+
>+ xine_event_dispose_queue(this->event_queue);
>+ this->event_queue = 0;
>+
>+ this->old_frame_left = 0;
>+ this->old_frame_top = 0;
>+ this->old_frame_width = 0;
>+ this->old_frame_height = 0;
>+ }
>+
>+ if (!this->vdr_stream
>+ && vdr_is_vdr_stream(stream))
>+ {
>+ this->event_queue = xine_event_new_queue(stream);
>+ if (this->event_queue)
>+ {
>+ this->vdr_stream = stream;
>+
>+ {
>+ xine_event_t event;
>+
>+ event.type = XINE_EVENT_VDR_PLUGINSTARTED;
>+ event.data = 0;
>+ event.data_length = 0; /* vdr_video */
>+
>+ xine_event_send(this->vdr_stream, &event);
>+ }
>+ }
>+ }
>+
>+ if (this->event_queue)
>+ {
>+ while ((event = xine_event_get(this->event_queue)))
>+ {
>+ if (event->type == XINE_EVENT_VDR_SETVIDEOWINDOW)
>+ {
>+ vdr_set_video_window_data_t *data = (vdr_set_video_window_data_t *)event->data;
>+
>+ vdr_video_set_video_window(this, data->x, data->y, data->w, data->h, data->w_ref, data->h_ref);
>+ }
>+ else if (event->type == XINE_EVENT_VDR_TRICKSPEEDMODE)
>+ {
>+/*
>+ fprintf(stderr, "###############################: %p, %d\n", event->data, event->data_length);
>+ this->trick_speed_mode = (0 != event->data_length);
>+*/
>+ }
>+
>+ xine_event_free(event);
>+ }
>+ }
>+
>+ {
>+ int frame_left = frame->crop_left;
>+ int frame_width = frame->width - frame->crop_left - frame->crop_right;
>+ int frame_top = frame->crop_top;
>+ int frame_height = frame->height - frame->crop_top - frame->crop_bottom;
>+
>+ if (frame_left < 0)
>+ frame_left = 0;
>+ if (frame_width > frame->width)
>+ frame_width = frame->width;
>+ if (frame_top < 0)
>+ frame_top = 0;
>+ if (frame_height > frame->height)
>+ frame_height = frame->height;
>+
>+ if (this->vdr_stream
>+ && (this->old_frame_left != frame_left
>+ || this->old_frame_top != frame_top
>+ || this->old_frame_width != frame_width
>+ || this->old_frame_height != frame_height))
>+ {
>+ xine_event_t event;
>+ vdr_frame_size_changed_data_t event_data;
>+
>+ event_data.x = frame_left;
>+ event_data.y = frame_top;
>+ event_data.w = frame_width;
>+ event_data.h = frame_height;
>+
>+ xprintf(this->vdr_stream->xine, XINE_VERBOSITY_LOG,
>+ _(LOG_MODULE ": osd: (%d, %d)-(%d, %d)\n"), frame_left, frame_top, frame_width, frame_height);
>+
>+ event.type = XINE_EVENT_VDR_FRAMESIZECHANGED;
>+ event.data = &event_data;
>+ event.data_length = sizeof (event_data);
>+
>+ xine_event_send(this->vdr_stream, &event);
>+
>+ this->old_frame_left = frame_left;
>+ this->old_frame_top = frame_top;
>+ this->old_frame_width = frame_width;
>+ this->old_frame_height = frame_height;
>+ }
>+ }
>+/*
>+ fprintf(stderr, "~~~~~~~~~~~~ trickspeedmode: %d\n", this->trick_speed_mode);
>+
>+ if (this->vdr_stream
>+ && this->trick_speed_mode)
>+ {
>+ frame->pts = 0;
>+ frame->next->pts = 0;
>+ }
>+*/
>+ if (!this->enabled
>+ || frame->bad_frame
>+ || (frame->format != XINE_IMGFMT_YUY2
>+ && frame->format != XINE_IMGFMT_YV12))
>+ {
>+ _x_post_frame_copy_down(frame, frame->next);
>+ skip = frame->next->draw(frame->next, stream);
>+ _x_post_frame_copy_up(frame, frame->next);
>+ return skip;
>+ }
>+
>+ vdr_frame = port->original_port->get_frame(port->original_port,
>+ frame->width, frame->height, frame->ratio, frame->format, frame->flags | VO_BOTH_FIELDS);
>+
>+ _x_post_frame_copy_down(frame, vdr_frame);
>+
>+ switch (vdr_frame->format)
>+ {
>+ case XINE_IMGFMT_YUY2:
>+ vdr_video_scale_YUY2(this, frame, vdr_frame);
>+ break;
>+
>+ case XINE_IMGFMT_YV12:
>+ vdr_video_scale_YV12(this, frame, vdr_frame);
>+ break;
>+ }
>+
>+ skip = vdr_frame->draw(vdr_frame, stream);
>+ _x_post_frame_copy_up(frame, vdr_frame);
>+ vdr_frame->free(vdr_frame);
>+
>+ return skip;
>+}
>diff -ruN xine-lib-1.1.1.orig/src/xine-engine/video_out.c xine-lib-1.1.1/src/xine-engine/video_out.c
>--- xine-lib-1.1.1.orig/src/xine-engine/video_out.c 2005-11-15 00:48:19.000000000 +0100
>+++ xine-lib-1.1.1/src/xine-engine/video_out.c 2006-01-02 20:07:20.000000000 +0100
>@@ -566,6 +566,7 @@
> vo_append_to_img_buf_queue (this->display_img_buf_queue, img);
>
> } else {
>+ fprintf (stderr, "bad_frame\n");
> lprintf ("bad_frame\n");
>
> if (stream) {
>diff -ruN xine-lib-1.1.1.orig/src/xine-engine/video_overlay.h xine-lib-1.1.1/src/xine-engine/video_overlay.h
>--- xine-lib-1.1.1.orig/src/xine-engine/video_overlay.h 2005-09-24 21:08:26.000000000 +0200
>+++ xine-lib-1.1.1/src/xine-engine/video_overlay.h 2006-01-02 20:08:00.000000000 +0100
>@@ -38,7 +38,7 @@
>
> #define MAX_OBJECTS 50
> #define MAX_EVENTS 50
>-#define MAX_SHOWING 16
>+#define MAX_SHOWING (5 + 16)
>
> #define OVERLAY_EVENT_NULL 0
> #define OVERLAY_EVENT_SHOW 1
>diff -ruN xine-lib-1.1.1.orig/src/xine-engine/xine.c xine-lib-1.1.1/src/xine-engine/xine.c
>--- xine-lib-1.1.1.orig/src/xine-engine/xine.c 2005-10-30 03:18:35.000000000 +0100
>+++ xine-lib-1.1.1/src/xine-engine/xine.c 2006-01-02 20:09:45.000000000 +0100
>@@ -1936,3 +1936,86 @@
> slave->master = master->master;
> return 1;
> }
>+
>+int _x_continue_stream_processing(xine_stream_t *stream)
>+{
>+ return stream->status != XINE_STATUS_STOP
>+ && stream->status != XINE_STATUS_QUIT;
>+}
>+
>+void _x_trigger_relaxed_frame_drop_mode(xine_stream_t *stream)
>+{
>+ stream->first_frame_flag = 2;
>+}
>+
>+void _x_reset_relaxed_frame_drop_mode(xine_stream_t *stream)
>+{
>+ stream->first_frame_flag = 1;
>+}
>+
>+void _x_query_buffer_usage(xine_stream_t *stream, int *num_video_buffers, int *num_audio_buffers, int *num_video_frames, int *num_audio_frames)
>+{
>+ stream->xine->port_ticket->acquire(stream->xine->port_ticket, 0);
>+
>+ if (num_video_buffers)
>+ *num_video_buffers = (stream->video_fifo ? stream->video_fifo->size(stream->video_fifo) : 0);
>+
>+ if (num_audio_buffers)
>+ *num_audio_buffers = (stream->audio_fifo ? stream->audio_fifo->size(stream->audio_fifo) : 0);
>+
>+ if (num_video_frames)
>+ *num_video_frames = (stream->video_out ? stream->video_out->get_property(stream->video_out, VO_PROP_BUFS_IN_FIFO) : 0);
>+
>+ if (num_audio_frames)
>+ *num_audio_frames = (stream->audio_out ? stream->audio_out->get_property(stream->audio_out, AO_PROP_BUFS_IN_FIFO) : 0);
>+
>+ stream->xine->port_ticket->release(stream->xine->port_ticket, 0);
>+}
>+
>+int _x_query_unprocessed_osd_events(xine_stream_t *stream)
>+{
>+ video_overlay_manager_t *ovl;
>+ int redraw_needed;
>+
>+ stream->xine->port_ticket->acquire(stream->xine->port_ticket, 0);
>+
>+ ovl = stream->video_out->get_overlay_manager(stream->video_out);
>+ redraw_needed = ovl->redraw_needed(ovl, 0);
>+
>+ stream->xine->port_ticket->release(stream->xine->port_ticket, 0);
>+
>+ return redraw_needed;
>+}
>+
>+int _x_demux_seek(xine_stream_t *stream, off_t start_pos, int start_time, int playing)
>+{
>+ return stream->demux_plugin->seek(stream->demux_plugin, start_pos, start_time, playing);
>+}
>+
>+int _x_lock_frontend(xine_stream_t *stream, int ms_to_time_out)
>+{
>+ if (ms_to_time_out >= 0) {
>+ struct timespec abstime;
>+
>+ struct timeval now;
>+ gettimeofday(&now, 0);
>+
>+ abstime.tv_sec = now.tv_sec + ms_to_time_out / 1000;
>+ abstime.tv_nsec = now.tv_usec * 1000 + (ms_to_time_out % 1000) * 1e6;
>+
>+ if (abstime.tv_nsec > 1e9) {
>+ abstime.tv_nsec -= 1e9;
>+ abstime.tv_sec++;
>+ }
>+
>+ return (0 == pthread_mutex_timedlock(&stream->frontend_lock, &abstime));
>+ }
>+
>+ pthread_mutex_lock(&stream->frontend_lock);
>+ return 1;
>+}
>+
>+void _x_unlock_frontend(xine_stream_t *stream)
>+{
>+ pthread_mutex_unlock(&stream->frontend_lock);
>+}
>diff -ruN xine-lib-1.1.1.orig/src/xine-engine/xine_internal.h xine-lib-1.1.1/src/xine-engine/xine_internal.h
>--- xine-lib-1.1.1.orig/src/xine-engine/xine_internal.h 2005-10-30 03:18:35.000000000 +0100
>+++ xine-lib-1.1.1/src/xine-engine/xine_internal.h 2006-01-02 20:10:34.000000000 +0100
>@@ -350,6 +350,15 @@
> * private function prototypes:
> */
>
>+int _x_continue_stream_processing(xine_stream_t *stream);
>+void _x_trigger_relaxed_frame_drop_mode(xine_stream_t *stream);
>+void _x_reset_relaxed_frame_drop_mode(xine_stream_t *stream);
>+void _x_query_buffer_usage(xine_stream_t *stream, int *num_video_buffers, int *num_audio_buffers, int *num_video_frames, int *num_audio_frames);
>+int _x_query_unprocessed_osd_events(xine_stream_t *stream);
>+int _x_demux_seek(xine_stream_t *stream, off_t start_pos, int start_time, int playing);
>+int _x_lock_frontend(xine_stream_t *stream, int ms_to_time_out);
>+void _x_unlock_frontend(xine_stream_t *stream);
>+
> void _x_handle_stream_end (xine_stream_t *stream, int non_user);
>
> /* report message to UI. usually these are async errors */
>
>
>------------------------------------------------------------------------
>
>diff -ruN xine-ui-0.99.4.orig/src/fb/actions.c xine-ui-0.99.4/src/fb/actions.c
>--- xine-ui-0.99.4.orig/src/fb/actions.c 2004-08-11 13:45:37.000000000 +0200
>+++ xine-ui-0.99.4/src/fb/actions.c 2006-01-02 20:32:42.000000000 +0100
>@@ -275,6 +275,8 @@
> "VDRVolumeMinus", ACTID_EVENT_VDR_VOLMINUS },
> { "VDR Audio Mute",
> "VDRMute", ACTID_EVENT_VDR_MUTE },
>+ { "VDR Audio menu",
>+ "VDRAudio", ACTID_EVENT_VDR_AUDIO },
> #endif
> { 0,
> 0, 0 }
>diff -ruN xine-ui-0.99.4.orig/src/fb/actions.h xine-ui-0.99.4/src/fb/actions.h
>--- xine-ui-0.99.4.orig/src/fb/actions.h 2004-08-11 13:45:38.000000000 +0200
>+++ xine-ui-0.99.4/src/fb/actions.h 2006-01-02 20:33:20.000000000 +0100
>@@ -188,7 +188,8 @@
> ACTID_EVENT_VDR_USER9 = XINE_EVENT_VDR_USER9 | ACTID_IS_INPUT_EVENT,
> ACTID_EVENT_VDR_VOLPLUS = XINE_EVENT_VDR_VOLPLUS | ACTID_IS_INPUT_EVENT,
> ACTID_EVENT_VDR_VOLMINUS = XINE_EVENT_VDR_VOLMINUS | ACTID_IS_INPUT_EVENT,
>- ACTID_EVENT_VDR_MUTE = XINE_EVENT_VDR_MUTE | ACTID_IS_INPUT_EVENT
>+ ACTID_EVENT_VDR_MUTE = XINE_EVENT_VDR_MUTE | ACTID_IS_INPUT_EVENT,
>+ ACTID_EVENT_VDR_AUDIO = XINE_EVENT_VDR_AUDIO | ACTID_IS_INPUT_EVENT
> #endif
>
> /*
>diff -ruN xine-ui-0.99.4.orig/src/xitk/kbindings.c xine-ui-0.99.4/src/xitk/kbindings.c
>--- xine-ui-0.99.4.orig/src/xitk/kbindings.c 2005-07-16 21:05:31.000000000 +0200
>+++ xine-ui-0.99.4/src/xitk/kbindings.c 2006-01-02 20:34:03.000000000 +0100
>@@ -511,6 +511,8 @@
> "VDRVolumeMinus", ACTID_EVENT_VDR_VOLMINUS , "VOID", KEYMOD_NOMOD , 0 , 0},
> { "VDR Audio Mute",
> "VDRMute", ACTID_EVENT_VDR_MUTE , "VOID", KEYMOD_NOMOD , 0 , 0},
>+ { "VDR Audio menu",
>+ "VDRAudio", ACTID_EVENT_VDR_AUDIO , "VOID", KEYMOD_NOMOD , 0 , 0},
> #endif
> { 0,
> 0, 0, 0, 0 , 0 , 0}
>diff -ruN xine-ui-0.99.4.orig/src/xitk/kbindings.h xine-ui-0.99.4/src/xitk/kbindings.h
>--- xine-ui-0.99.4.orig/src/xitk/kbindings.h 2005-07-16 21:05:31.000000000 +0200
>+++ xine-ui-0.99.4/src/xitk/kbindings.h 2006-01-02 20:34:28.000000000 +0100
>@@ -209,7 +209,8 @@
> ACTID_EVENT_VDR_USER9 = XINE_EVENT_VDR_USER9 | ACTID_IS_INPUT_EVENT,
> ACTID_EVENT_VDR_VOLPLUS = XINE_EVENT_VDR_VOLPLUS | ACTID_IS_INPUT_EVENT,
> ACTID_EVENT_VDR_VOLMINUS = XINE_EVENT_VDR_VOLMINUS | ACTID_IS_INPUT_EVENT,
>- ACTID_EVENT_VDR_MUTE = XINE_EVENT_VDR_MUTE | ACTID_IS_INPUT_EVENT
>+ ACTID_EVENT_VDR_MUTE = XINE_EVENT_VDR_MUTE | ACTID_IS_INPUT_EVENT,
>+ ACTID_EVENT_VDR_AUDIO = XINE_EVENT_VDR_AUDIO | ACTID_IS_INPUT_EVENT
> #endif
>
> /*
>
>
>------------------------------------------------------------------------
>
>_______________________________________________
>vdr mailing list
>vdr@xxxxxxxxxxx
>http://www.linuxtv.org/cgi-bin/mailman/listinfo/vdr
>
>
