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@gmail.com 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@linuxtv.org http://www.linuxtv.org/cgi-bin/mailman/listinfo/vdr