From 0638ad373d88c3ed45273a505df56626daba19a0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Fri, 13 Apr 2007 00:17:30 +0200
Subject: Provide ability to lock port rewiring. The idea is to allow only a
 "single" frontend to rewire ports at a certain point in time. Regarding a
 stream, frontend_lock is used for example to allow only a single frontend to
 change the speed. Unfortunately, frontend_lock cannot be used as the rewire
 functions are not stream related. Therefore a new port_rewiring_lock was
 introduced and used at appropriate locations. When an arbitrary thread now
 holds the frontend_lock and the port_rewiring_lock, it is safe that acquiring
 a port ticket in functions like xine_get_current_frame() will never block the
 thread.

---
 src/xine-engine/post.c          |  4 ++++
 src/xine-engine/xine.c          | 36 ++++++++++++++++++++++++++++++++++++
 src/xine-engine/xine_internal.h |  4 ++++
 3 files changed, 44 insertions(+)

(limited to 'src')

diff --git a/src/xine-engine/post.c b/src/xine-engine/post.c
index 6ae96e982..58e9b633c 100644
--- a/src/xine-engine/post.c
+++ b/src/xine-engine/post.c
@@ -192,6 +192,7 @@ static int post_video_rewire(xine_post_out_t *output_gen, void *data) {
   if (!new_port)
     return 0;
   
+  this->running_ticket->lock_port_rewiring(this->running_ticket, -1);
   this->running_ticket->revoke(this->running_ticket, 1);
   
   if (input_port->original_port->status(input_port->original_port, input_port->stream,
@@ -202,6 +203,7 @@ static int post_video_rewire(xine_post_out_t *output_gen, void *data) {
   input_port->original_port = new_port;
   
   this->running_ticket->issue(this->running_ticket, 1);
+  this->running_ticket->unlock_port_rewiring(this->running_ticket);
   
   return 1;
 }
@@ -680,6 +682,7 @@ static int post_audio_rewire(xine_post_out_t *output_gen, void *data) {
   if (!new_port)
     return 0;
   
+  this->running_ticket->lock_port_rewiring(this->running_ticket, -1);
   this->running_ticket->revoke(this->running_ticket, 1);
   
   if (input_port->original_port->status(input_port->original_port, input_port->stream,
@@ -690,6 +693,7 @@ static int post_audio_rewire(xine_post_out_t *output_gen, void *data) {
   input_port->original_port = new_port;
   
   this->running_ticket->issue(this->running_ticket, 1);
+  this->running_ticket->unlock_port_rewiring(this->running_ticket);
   
   return 1;
 }
diff --git a/src/xine-engine/xine.c b/src/xine-engine/xine.c
index 612bf8dcc..aa84917bb 100644
--- a/src/xine-engine/xine.c
+++ b/src/xine-engine/xine.c
@@ -239,8 +239,37 @@ static void ticket_revoke(xine_ticket_t *this, int atomic) {
     pthread_mutex_unlock(&this->revoke_lock);
 }
 
+static int ticket_lock_port_rewiring(xine_ticket_t *this, int ms_timeout) {
+
+  if (ms_timeout >= 0) {
+    struct timespec abstime;
+
+    struct timeval now;
+    gettimeofday(&now, 0);
+
+    abstime.tv_sec = now.tv_sec + ms_timeout / 1000;
+    abstime.tv_nsec = now.tv_usec * 1000 + (ms_timeout % 1000) * 1e6;
+
+    if (abstime.tv_nsec > 1e9) {
+      abstime.tv_nsec -= 1e9;
+      abstime.tv_sec++;
+    }
+
+    return (0 == pthread_mutex_timedlock(&this->port_rewiring_lock, &abstime));
+  }
+
+  pthread_mutex_lock(&this->port_rewiring_lock);
+  return 1;
+}
+
+static void ticket_unlock_port_rewiring(xine_ticket_t *this) {
+
+  pthread_mutex_unlock(&this->port_rewiring_lock);
+}
+
 static void ticket_dispose(xine_ticket_t *this) {
 
+  pthread_mutex_destroy(&this->port_rewiring_lock);
   pthread_mutex_destroy(&this->lock);
   pthread_mutex_destroy(&this->revoke_lock);
   pthread_cond_destroy(&this->issued);
@@ -261,10 +290,13 @@ static xine_ticket_t *ticket_init(void) {
   port_ticket->renew                = ticket_renew;
   port_ticket->issue                = ticket_issue;
   port_ticket->revoke               = ticket_revoke;
+  port_ticket->lock_port_rewiring   = ticket_lock_port_rewiring;
+  port_ticket->unlock_port_rewiring = ticket_unlock_port_rewiring;
   port_ticket->dispose              = ticket_dispose;
   
   pthread_mutex_init(&port_ticket->lock, NULL);
   pthread_mutex_init(&port_ticket->revoke_lock, NULL);
+  pthread_mutex_init(&port_ticket->port_rewiring_lock, NULL);
   pthread_cond_init(&port_ticket->issued, NULL);
   pthread_cond_init(&port_ticket->revoked, NULL);
   
@@ -458,6 +490,7 @@ static int stream_rewire_audio(xine_post_out_t *output, void *data)
   if (!data)
     return 0;
 
+  stream->xine->port_ticket->lock_port_rewiring(stream->xine->port_ticket, -1);
   stream->xine->port_ticket->revoke(stream->xine->port_ticket, 1);
   
   if (stream->audio_out->status(stream->audio_out, stream, &bits, &rate, &mode)) {
@@ -468,6 +501,7 @@ static int stream_rewire_audio(xine_post_out_t *output, void *data)
   stream->audio_out = new_port;
   
   stream->xine->port_ticket->issue(stream->xine->port_ticket, 1);
+  stream->xine->port_ticket->unlock_port_rewiring(stream->xine->port_ticket);
 
   return 1;
 }
@@ -482,6 +516,7 @@ static int stream_rewire_video(xine_post_out_t *output, void *data)
   if (!data)
     return 0;
 
+  stream->xine->port_ticket->lock_port_rewiring(stream->xine->port_ticket, -1);
   stream->xine->port_ticket->revoke(stream->xine->port_ticket, 1);
   
   if (stream->video_out->status(stream->video_out, stream, &width, &height, &img_duration)) {
@@ -492,6 +527,7 @@ static int stream_rewire_video(xine_post_out_t *output, void *data)
   stream->video_out = new_port;
   
   stream->xine->port_ticket->issue(stream->xine->port_ticket, 1);
+  stream->xine->port_ticket->unlock_port_rewiring(stream->xine->port_ticket);
 
   return 1;
 }
diff --git a/src/xine-engine/xine_internal.h b/src/xine-engine/xine_internal.h
index da6f88a7f..e11c3e667 100644
--- a/src/xine-engine/xine_internal.h
+++ b/src/xine-engine/xine_internal.h
@@ -168,6 +168,9 @@ struct xine_ticket_s {
    * be used in combination with acquire_nonblocking() */
   void (*release_nonblocking)(xine_ticket_t *self, int irrevocable);
 
+  int (*lock_port_rewiring)(xine_ticket_t *self, int ms_timeout);
+  void (*unlock_port_rewiring)(xine_ticket_t *self);
+
   void (*dispose)(xine_ticket_t *self);
   
   pthread_mutex_t lock;
@@ -179,6 +182,7 @@ struct xine_ticket_s {
   int             pending_revocations;
   int             atomic_revoke;
   pthread_t       atomic_revoker_thread;
+  pthread_mutex_t port_rewiring_lock;
 #endif
 };
 
-- 
cgit v1.2.3


From 31bb62fae17fe849704c5d3fe78090a3df92cead Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Fri, 13 Apr 2007 00:32:19 +0200
Subject: Provide internal functions to lock port rewiring. The introduced
 function give "frontend like" plugins a chance to lock and unlock port
 rewiring. This protects such threads (when combined with holding the frontend
 lock) from beeing blocked when calling functions like
 xine_get_current_frame().

---
 src/xine-engine/xine.c          | 10 ++++++++++
 src/xine-engine/xine_internal.h |  2 ++
 2 files changed, 12 insertions(+)

(limited to 'src')

diff --git a/src/xine-engine/xine.c b/src/xine-engine/xine.c
index a780aa4dc..1a9a2be4d 100644
--- a/src/xine-engine/xine.c
+++ b/src/xine-engine/xine.c
@@ -2133,3 +2133,13 @@ int _x_query_buffer_usage(xine_stream_t *stream, int *num_video_buffers, int *nu
 
   return ticket_acquired != 0;
 }
+
+int _x_lock_port_rewiring(xine_t *xine, int ms_timeout)
+{
+  return xine->port_ticket->lock_port_rewiring(xine->port_ticket, ms_timeout);
+}
+
+void _x_unlock_port_rewiring(xine_t *xine)
+{
+  xine->port_ticket->unlock_port_rewiring(xine->port_ticket);
+}
diff --git a/src/xine-engine/xine_internal.h b/src/xine-engine/xine_internal.h
index db95d064a..4fa31a969 100644
--- a/src/xine-engine/xine_internal.h
+++ b/src/xine-engine/xine_internal.h
@@ -371,6 +371,8 @@ struct xine_stream_s {
  */
 
 int _x_query_buffer_usage(xine_stream_t *stream, int *num_video_buffers, int *num_audio_buffers, int *num_video_frames, int *num_audio_frames) XINE_PROTECTED;
+int _x_lock_port_rewiring(xine_t *xine, int ms_to_time_out) XINE_PROTECTED;
+void _x_unlock_port_rewiring(xine_t *xine) XINE_PROTECTED;
 
 void _x_handle_stream_end      (xine_stream_t *stream, int non_user) XINE_PROTECTED;
 
-- 
cgit v1.2.3


From f8e051109fc70cbf7acbfd6582bc2f6d03e6d93b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Fri, 13 Apr 2007 00:39:06 +0200
Subject: Provide internal functions to lock frontend_lock. The introduced
 functions give "frontend like" plugins a chance to lock and unlock
 frontend_lock. This protects such threads for example from beeing blocked
 when changing the streams speed.

---
 src/xine-engine/xine.c          | 28 ++++++++++++++++++++++++++++
 src/xine-engine/xine_internal.h |  2 ++
 2 files changed, 30 insertions(+)

(limited to 'src')

diff --git a/src/xine-engine/xine.c b/src/xine-engine/xine.c
index 1a9a2be4d..ce7713810 100644
--- a/src/xine-engine/xine.c
+++ b/src/xine-engine/xine.c
@@ -2143,3 +2143,31 @@ void _x_unlock_port_rewiring(xine_t *xine)
 {
   xine->port_ticket->unlock_port_rewiring(xine->port_ticket);
 }
+
+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 --git a/src/xine-engine/xine_internal.h b/src/xine-engine/xine_internal.h
index 4fa31a969..511b13a0d 100644
--- a/src/xine-engine/xine_internal.h
+++ b/src/xine-engine/xine_internal.h
@@ -373,6 +373,8 @@ struct xine_stream_s {
 int _x_query_buffer_usage(xine_stream_t *stream, int *num_video_buffers, int *num_audio_buffers, int *num_video_frames, int *num_audio_frames) XINE_PROTECTED;
 int _x_lock_port_rewiring(xine_t *xine, int ms_to_time_out) XINE_PROTECTED;
 void _x_unlock_port_rewiring(xine_t *xine) XINE_PROTECTED;
+int _x_lock_frontend(xine_stream_t *stream, int ms_to_time_out) XINE_PROTECTED;
+void _x_unlock_frontend(xine_stream_t *stream) XINE_PROTECTED;
 
 void _x_handle_stream_end      (xine_stream_t *stream, int non_user) XINE_PROTECTED;
 
-- 
cgit v1.2.3


From ee7faf25388d4a2890bf3fa55288391cfe04851a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Sun, 15 Apr 2007 20:43:42 +0200
Subject: Provide a function to query for outstanding OSD events. This function
 shall be used to poll the number of outstanding OSD events from a certain
 point in time on until the reported number is 0. At that point in time, the
 content on screen is identical to a certain state of the stream, at which for
 example, a hardcopy may be taken.

---
 src/xine-engine/xine.c          | 19 +++++++++++++++++++
 src/xine-engine/xine_internal.h |  1 +
 2 files changed, 20 insertions(+)

(limited to 'src')

diff --git a/src/xine-engine/xine.c b/src/xine-engine/xine.c
index ce7713810..840c91f3f 100644
--- a/src/xine-engine/xine.c
+++ b/src/xine-engine/xine.c
@@ -2171,3 +2171,22 @@ void _x_unlock_frontend(xine_stream_t *stream)
 {
   pthread_mutex_unlock(&stream->frontend_lock);
 }
+
+int _x_query_unprocessed_osd_events(xine_stream_t *stream)
+{
+  video_overlay_manager_t *ovl;
+  int redraw_needed;
+  
+  if (!stream->xine->port_ticket->acquire_nonblocking(stream->xine->port_ticket, 1))
+    return -1;
+
+  ovl = stream->video_out->get_overlay_manager(stream->video_out);
+  redraw_needed = ovl->redraw_needed(ovl, 0);
+ 
+  if (redraw_needed) 
+    stream->video_out->trigger_drawing(stream->video_out);
+
+  stream->xine->port_ticket->release_nonblocking(stream->xine->port_ticket, 1);
+
+  return redraw_needed;
+}
diff --git a/src/xine-engine/xine_internal.h b/src/xine-engine/xine_internal.h
index 511b13a0d..f4041452d 100644
--- a/src/xine-engine/xine_internal.h
+++ b/src/xine-engine/xine_internal.h
@@ -375,6 +375,7 @@ int _x_lock_port_rewiring(xine_t *xine, int ms_to_time_out) XINE_PROTECTED;
 void _x_unlock_port_rewiring(xine_t *xine) XINE_PROTECTED;
 int _x_lock_frontend(xine_stream_t *stream, int ms_to_time_out) XINE_PROTECTED;
 void _x_unlock_frontend(xine_stream_t *stream) XINE_PROTECTED;
+int _x_query_unprocessed_osd_events(xine_stream_t *stream) XINE_PROTECTED;
 
 void _x_handle_stream_end      (xine_stream_t *stream, int non_user) XINE_PROTECTED;
 
-- 
cgit v1.2.3


From 3b03ad66fd2d5a475938a28cbcd55ba0319204a9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Sun, 15 Apr 2007 21:08:32 +0200
Subject: Make sleeps in video out loops interruptable for immediate OSD
 redrawing. The video out loop sleeps up to 20 ms (and the paused loop 20 ms)
 which means that pending OSD events are delayed too from beeing processed.
 When an OSD is used for example to scroll through a list of VDR recordings,
 this delay may slow down scrolling unnecessarily. Especially when the OSD
 manager is able to render the OSD content indepently from drawing a frame to
 screen, this change will allow the fastest OSD update possible.

---
 src/xine-engine/post.c      |  9 +++++++++
 src/xine-engine/video_out.c | 49 +++++++++++++++++++++++++++++++++++++++++++--
 src/xine-engine/video_out.h |  3 +++
 3 files changed, 59 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/xine-engine/post.c b/src/xine-engine/post.c
index 58e9b633c..0dba50c82 100644
--- a/src/xine-engine/post.c
+++ b/src/xine-engine/post.c
@@ -149,6 +149,14 @@ static void post_video_flush(xine_video_port_t *port_gen) {
   if (port->port_lock) pthread_mutex_unlock(port->port_lock);
 }
 
+static void post_video_trigger_drawing(xine_video_port_t *port_gen) {
+  post_video_port_t *port = (post_video_port_t *)port_gen;
+  
+  if (port->port_lock) pthread_mutex_lock(port->port_lock);
+  port->original_port->trigger_drawing(port->original_port);
+  if (port->port_lock) pthread_mutex_unlock(port->port_lock);
+}
+
 static int post_video_status(xine_video_port_t *port_gen, xine_stream_t *stream,
                              int *width, int *height, int64_t *img_duration) {
   post_video_port_t *port = (post_video_port_t *)port_gen;
@@ -225,6 +233,7 @@ post_video_port_t *_x_post_intercept_video_port(post_plugin_t *post, xine_video_
   port->new_port.exit                = post_video_exit;
   port->new_port.get_overlay_manager = post_video_get_overlay_manager;
   port->new_port.flush               = post_video_flush;
+  port->new_port.trigger_drawing     = post_video_trigger_drawing;
   port->new_port.status              = post_video_status;
   port->new_port.get_property        = post_video_get_property;
   port->new_port.set_property        = post_video_set_property;
diff --git a/src/xine-engine/video_out.c b/src/xine-engine/video_out.c
index 2a3ee1980..d61df1eb2 100644
--- a/src/xine-engine/video_out.c
+++ b/src/xine-engine/video_out.c
@@ -1043,6 +1043,32 @@ static void check_redraw_needed (vos_t *this, int64_t vpts) {
     this->redraw_needed = 1;
 }
 
+static int interruptable_sleep(vos_t *this, int usec_to_sleep)
+{
+  int timedout = 0;
+
+  struct timeval now;
+  gettimeofday(&now, 0);
+
+  pthread_mutex_lock (&this->trigger_drawing_mutex);
+  if (!this->trigger_drawing) {
+    struct timespec abstime;
+    abstime.tv_sec  = now.tv_sec + usec_to_sleep / 1000000;
+    abstime.tv_nsec = now.tv_usec * 1000 + (usec_to_sleep % 1000000) * 1000;
+
+    if (abstime.tv_nsec > 1000000000) {
+      abstime.tv_nsec -= 1000000000;
+      abstime.tv_sec++;
+    }
+
+    timedout = pthread_cond_timedwait(&this->trigger_drawing_cond, &this->trigger_drawing_mutex, &abstime);
+  }
+  this->trigger_drawing = 0;
+  pthread_mutex_unlock (&this->trigger_drawing_mutex);
+
+  return timedout;
+}
+
 /* special loop for paused mode
  * needed to update screen due overlay changes, resize, window
  * movement, brightness adjusting etc.
@@ -1088,7 +1114,7 @@ static void paused_loop( vos_t *this, int64_t vpts )
     }
     
     pthread_mutex_unlock( &this->free_img_buf_queue->mutex );
-    xine_usec_sleep (20000);
+    interruptable_sleep(this, 20000);
     pthread_mutex_lock( &this->free_img_buf_queue->mutex );
   }
   
@@ -1218,7 +1244,10 @@ static void *video_out_loop (void *this_gen) {
 		"video_out: vpts/clock error, next_vpts=%" PRId64 " cur_vpts=%" PRId64 "\n", next_frame_vpts,vpts);
                
       if (usec_to_sleep > 0)
-        xine_usec_sleep (usec_to_sleep);
+      {
+        if (0 == interruptable_sleep(this, usec_to_sleep))
+          break;
+      }
 
       if (this->discard_frames)
         break;
@@ -1601,6 +1630,9 @@ static void vo_exit (xine_video_port_t *this_gen) {
   free (this->free_img_buf_queue);
   free (this->display_img_buf_queue);
 
+  pthread_cond_destroy(&this->trigger_drawing_cond);
+  pthread_mutex_destroy(&this->trigger_drawing_mutex);
+
   free (this);
 }
 
@@ -1670,6 +1702,15 @@ static void vo_flush (xine_video_port_t *this_gen) {
   }
 }
 
+static void vo_trigger_drawing (xine_video_port_t *this_gen) {
+  vos_t      *this = (vos_t *) this_gen;
+
+  pthread_mutex_lock (&this->trigger_drawing_mutex);
+  this->trigger_drawing = 1;
+  pthread_cond_signal (&this->trigger_drawing_cond);
+  pthread_mutex_unlock (&this->trigger_drawing_mutex);
+}
+
 /* crop_frame() will allocate a new frame to copy in the given image
  * while cropping. maybe someday this will be an automatic post plugin.
  */
@@ -1765,6 +1806,7 @@ xine_video_port_t *_x_vo_new_port (xine_t *xine, vo_driver_t *driver, int grabon
   this->vo.enable_ovl            = vo_enable_overlay;
   this->vo.get_overlay_manager   = vo_get_overlay_manager;
   this->vo.flush                 = vo_flush;
+  this->vo.trigger_drawing       = vo_trigger_drawing;
   this->vo.get_property          = vo_get_property;
   this->vo.set_property          = vo_set_property;
   this->vo.status                = vo_status;
@@ -1842,6 +1884,9 @@ xine_video_port_t *_x_vo_new_port (xine_t *xine, vo_driver_t *driver, int grabon
       "were not scheduled for display in time, xine sends a notification."),
     20, NULL, NULL);
 
+  pthread_mutex_init(&this->trigger_drawing_mutex, NULL);
+  pthread_cond_init(&this->trigger_drawing_cond, NULL);
+  this->trigger_drawing = 0;
 
   if (grabonly) {
 
diff --git a/src/xine-engine/video_out.h b/src/xine-engine/video_out.h
index 7b42c43ed..06e5eaaa9 100644
--- a/src/xine-engine/video_out.h
+++ b/src/xine-engine/video_out.h
@@ -205,6 +205,9 @@ struct xine_video_port_s {
   /* flush video_out fifo */
   void (*flush) (xine_video_port_t *self);
 
+  /* trigger immediate drawing */
+  void (*trigger_drawing) (xine_video_port_t *self);
+
   /* Get/Set video property
    *
    * See VO_PROP_* bellow
-- 
cgit v1.2.3


From b55b86b40e17a331fe2131ba4e6e3e76d0ba061c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Sun, 15 Apr 2007 21:23:35 +0200
Subject: Increase priority of video decoder a little bit, to avoid frame
 drops. When a video out device provides only a little number of video frames,
 the video decoder should be scheduled immediately to provide a decoded frame
 as soon as possible. Otherwise, the number of available frames for displaying
 may go below frame drop limit and thus resulting in unnecessary frame drops.

---
 src/xine-engine/video_decoder.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'src')

diff --git a/src/xine-engine/video_decoder.c b/src/xine-engine/video_decoder.c
index fee75ec76..3d39b4550 100644
--- a/src/xine-engine/video_decoder.c
+++ b/src/xine-engine/video_decoder.c
@@ -28,6 +28,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 #define XINE_ENGINE_INTERNAL
 
@@ -110,6 +111,15 @@ static void *video_decoder_loop (void *stream_gen) {
   int              prof_video_decode = -1;
   int              prof_spu_decode = -1;
   uint32_t         buftype_unknown = 0;
+
+#ifndef WIN32
+  /* nice(-value) will fail silently for normal users.
+   * however when running as root this may provide smoother
+   * playback. follow the link for more information:
+   * http://cambuca.ldhs.cetuc.puc-rio.br/~miguel/multimedia_sim/
+   */
+  nice(-1);
+#endif /* WIN32 */
   
   if (prof_video_decode == -1)
     prof_video_decode = xine_profiler_allocate_slot ("video decoder");
-- 
cgit v1.2.3


From bcf37512cdb7e72162917ceb5dfa7bbc4d486485 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Sun, 15 Apr 2007 21:39:37 +0200
Subject: Avoid skipping an unsuitable frame when there are only few buffers
 available. Usually it's a good idea to avoid reallocating frames especially
 when a deinterlacer needs a different format than the decoder, as this would
 then happen all the time. But when there is only a limited number of frames
 available, then even a single frame which is not scheduled at frame
 allocation may let the number of frames ready for displaying drop below frame
 drop limit and thus resulting in unnecessary frame drops.

---
 src/xine-engine/video_out.c | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

(limited to 'src')

diff --git a/src/xine-engine/video_out.c b/src/xine-engine/video_out.c
index d61df1eb2..852e13524 100644
--- a/src/xine-engine/video_out.c
+++ b/src/xine-engine/video_out.c
@@ -71,6 +71,7 @@ typedef struct {
   vo_frame_t        *first;
   vo_frame_t        *last;
   int                num_buffers;
+  int                num_buffers_max;
 
   int                locked_for_read;
   pthread_mutex_t    mutex;
@@ -144,9 +145,11 @@ static img_buf_fifo_t *vo_new_img_buf_queue () {
 
   queue = (img_buf_fifo_t *) xine_xmalloc (sizeof (img_buf_fifo_t));
   if( queue ) {
-    queue->first       = NULL;
-    queue->last        = NULL;
-    queue->num_buffers = 0;
+    queue->first           = NULL;
+    queue->last            = NULL;
+    queue->num_buffers     = 0;
+    queue->num_buffers_max = 0;
+
     queue->locked_for_read = 0;
     pthread_mutex_init (&queue->mutex, NULL);
     pthread_cond_init  (&queue->not_empty, NULL);
@@ -173,6 +176,8 @@ static void vo_append_to_img_buf_queue_int (img_buf_fifo_t *queue,
   }
 
   queue->num_buffers++;
+  if (queue->num_buffers_max < queue->num_buffers)
+    queue->num_buffers_max = queue->num_buffers;
 
   pthread_cond_signal (&queue->not_empty);
 }
@@ -213,14 +218,15 @@ static vo_frame_t *vo_remove_from_img_buf_queue_int (img_buf_fifo_t *queue, int
       
       if( width && height ) {
         if( !img ) {
-          if( queue->num_buffers == 1 && !blocking) {
+          if( queue->num_buffers == 1 && !blocking && queue->num_buffers_max > 8) {
             /* non-blocking and only a single frame on fifo with different
              * format -> ignore it (give another chance of a frame format hit)
+             * only if we have a lot of buffers at all.
              */
             lprintf("frame format mismatch - will wait another frame\n");
           } else {
-            /* we have at least 2 frames on fifo but they don't match ->
-             * give up. return whatever we got.
+            /* we have just a limited number of buffers or at least 2 frames
+             * on fifo but they don't match -> give up. return whatever we got.
              */
             img = queue->first;
             lprintf("frame format miss (%d/%d)\n", i, queue->num_buffers);
-- 
cgit v1.2.3


From 1d5c7d9f5766b92de1e0c43b38af3086b3560cef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Sun, 15 Apr 2007 22:11:18 +0200
Subject: Choose maximum for frame drop limit depending on the number of
 allocated frames. The current code uses a hard coded frame drop limit of 3
 and doesn't adhere to it's documentation when testing whether frames shall be
 dropped. As a result frame drop limit is actually 4, which means that the
 decoder is asked to drop some frames when the number of frames waiting for
 displaying is less then 4. Consider a video out device like xxmc which only
 supplies 8 frames. For MPEG2 decoding, two frames will be used by the decoder
 (for the current frame and the forward reference frame) and two further
 frames will be used in the video out loop (the current and the previous
 frame) so that at any given time (under perfect conditions) there will be 4
 frames waiting to be displayed. But when there are delays in scheduling, it
 might happen that there are only 3 frames ready for displaying and thus will
 result in asking the decoder to drop frames. The changes therefore determine
 the maximum frame drop limit in dependence of the number of allocated frames
 and make the detection work like documented. In the above scenario, the
 maximum number actually used for frame drop limit will then be 2 which allows
 to compensate some scheduling delays without causing the decoder to drop
 frames.

---
 src/xine-engine/video_out.c | 31 +++++++++++++++++++++++++------
 1 file changed, 25 insertions(+), 6 deletions(-)

(limited to 'src')

diff --git a/src/xine-engine/video_out.c b/src/xine-engine/video_out.c
index 852e13524..c75b7058a 100644
--- a/src/xine-engine/video_out.c
+++ b/src/xine-engine/video_out.c
@@ -129,6 +129,7 @@ typedef struct {
 
   int                       current_width, current_height;
   int64_t                   current_duration;
+  int                       frame_drop_limit_max;
   int                       frame_drop_limit;
   int                       frame_drop_cpt;
   int                       crop_left, crop_right, crop_top, crop_bottom;
@@ -473,25 +474,28 @@ static int vo_frame_draw (vo_frame_t *img, xine_stream_t *stream) {
       duration = img->duration;
     
     /* Frame dropping slow start:
-     *   The engine starts to drop frames if there is less than frame_drop_limit
+     *   The engine starts to drop frames if there are less than frame_drop_limit
      *   frames in advance. There might be a problem just after a seek because
      *   there is no frame in advance yet.
      *   The following code increases progressively the frame_drop_limit (-2 -> 3)
      *   after a seek to give a chance to the engine to display the first frames
-     *   smootly before starting to drop frames if the decoder is really too
+     *   smoothly before starting to drop frames if the decoder is really too
      *   slow.
+     *   The above numbers are the result of frame_drop_limit_max beeing 3. They
+     *   will be (-4 -> 1) when frame_drop_limit_max is only 1. This maximum value
+     *   depends on the number of video buffers which the output device provides.
      */
     if (stream && stream->first_frame_flag == 2)
       this->frame_drop_cpt = 10;
 
     if (this->frame_drop_cpt) {
-      this->frame_drop_limit = 3 - (this->frame_drop_cpt / 2);
+      this->frame_drop_limit = this->frame_drop_limit_max - (this->frame_drop_cpt / 2);
       this->frame_drop_cpt--;
     }
     frames_to_skip = ((-1 * diff) / duration + this->frame_drop_limit) * 2;
 
     /* do not skip decoding until output fifo frames are consumed */
-    if (this->display_img_buf_queue->num_buffers > this->frame_drop_limit ||
+    if (this->display_img_buf_queue->num_buffers >= this->frame_drop_limit ||
         frames_to_skip < 0)
       frames_to_skip = 0;
       
@@ -1832,8 +1836,6 @@ xine_video_port_t *_x_vo_new_port (xine_t *xine, vo_driver_t *driver, int grabon
   this->overlay_source->init (this->overlay_source);
   this->overlay_enabled       = 1;
 
-  this->frame_drop_limit      = 3;
-  this->frame_drop_cpt        = 0;
 
   /* default number of video frames from config */
   num_frame_buffers = xine->config->register_num (xine->config,
@@ -1854,6 +1856,23 @@ xine_video_port_t *_x_vo_new_port (xine_t *xine, vo_driver_t *driver, int grabon
   if (num_frame_buffers<5) 
     num_frame_buffers = 5;
 
+  /* Choose a frame_drop_limit which matches num_frame_buffers.
+   * xxmc for example supplies only 8 buffers. 2 are occupied by
+   * MPEG2 decoding, further 2 for displaying and the remaining 4 can
+   * hardly be filled all the time.
+   * The below constants reserve buffers for decoding, displaying and
+   * buffer fluctuation.
+   * A frame_drop_limit_max below 1 will disable frame drops at all.
+   */
+  this->frame_drop_limit_max  = num_frame_buffers - 2 - 2 - 1;
+  if (this->frame_drop_limit_max < 1)
+    this->frame_drop_limit_max = 1;
+  else if (this->frame_drop_limit_max > 3)
+    this->frame_drop_limit_max = 3;
+
+  this->frame_drop_limit      = this->frame_drop_limit_max;
+  this->frame_drop_cpt        = 0;
+
   this->extra_info_base = calloc (num_frame_buffers,
 					  sizeof(extra_info_t));
 
-- 
cgit v1.2.3


From b18b4faf8fa913ccaeec3003d6bcfa273267db30 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Sun, 15 Apr 2007 22:21:51 +0200
Subject: Avoid immediate frame drops by giving decoder a further chance to
 supply decoded frames. There can still be scheduling delays which may let the
 number of frames ready for displaying to drop below frame drop limit just for
 a short period of time. Therefore the changes remember that the decoder
 should have been asked to drop some frames but do not actually have the
 decoder to drop some frames. When the situation has improved at the next time
 when the check is performed, the remembered frame drop is canceled or
 otherwise (when the number of frames is still below frame drop limit)
 executed.

---
 src/xine-engine/video_out.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

(limited to 'src')

diff --git a/src/xine-engine/video_out.c b/src/xine-engine/video_out.c
index c75b7058a..6177cbef8 100644
--- a/src/xine-engine/video_out.c
+++ b/src/xine-engine/video_out.c
@@ -132,6 +132,7 @@ typedef struct {
   int                       frame_drop_limit_max;
   int                       frame_drop_limit;
   int                       frame_drop_cpt;
+  int                       frame_drop_suggested;
   int                       crop_left, crop_right, crop_top, crop_bottom;
 } vos_t;
 
@@ -499,6 +500,21 @@ static int vo_frame_draw (vo_frame_t *img, xine_stream_t *stream) {
         frames_to_skip < 0)
       frames_to_skip = 0;
       
+    /* Do not drop frames immediately, but remember this as suggestion and give
+     * decoder a further chance to supply frames.
+     * This avoids unnecessary frame drops in situations where there is only
+     * a very little number of image buffers, e. g. when using xxmc.
+     */
+    if (this->frame_drop_suggested && frames_to_skip == 0)
+      this->frame_drop_suggested = 0;
+
+    if (frames_to_skip > 0) {
+      if (!this->frame_drop_suggested) {
+        this->frame_drop_suggested = 1;
+        frames_to_skip = 0;
+      }
+    }
+
     lprintf ("delivery diff : %" PRId64 ", current vpts is %" PRId64 ", %d frames to skip\n",
 	     diff, cur_vpts, frames_to_skip);
     
@@ -1872,6 +1888,7 @@ xine_video_port_t *_x_vo_new_port (xine_t *xine, vo_driver_t *driver, int grabon
 
   this->frame_drop_limit      = this->frame_drop_limit_max;
   this->frame_drop_cpt        = 0;
+  this->frame_drop_suggested  = 0;
 
   this->extra_info_base = calloc (num_frame_buffers,
 					  sizeof(extra_info_t));
-- 
cgit v1.2.3


From 6131a63cad60f0e3c452ec9486e9c496b42bed82 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Sun, 15 Apr 2007 22:25:20 +0200
Subject: Avoid locking log_lock once the buffer has been allocated.

---
 src/xine-engine/xine.c | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'src')

diff --git a/src/xine-engine/xine.c b/src/xine-engine/xine.c
index 840c91f3f..3109ac719 100644
--- a/src/xine-engine/xine.c
+++ b/src/xine-engine/xine.c
@@ -2034,6 +2034,9 @@ const char *const *xine_get_log_names (xine_t *this) {
 
 static inline void check_log_alloc (xine_t *this, int buf)
 {
+  if ( this->log_buffers[buf] )
+    return;
+
   pthread_mutex_lock (&this->log_lock);
 
   if ( ! this->log_buffers[buf] )
-- 
cgit v1.2.3


From a0795aa171b7972c48e8a42ae5dc50cde0975005 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Sun, 15 Apr 2007 22:51:19 +0200
Subject: Extend the original MAX_SHOWING by 16 VDR OSD objects. The original
 number of OSD objects was 5 which served xine-lib's needs. VDR may on it's
 own allocate up to 16 OSD objects and thus there may be no more OSD objects
 left for xine-lib's needs. The change addresses this by increasing the
 current number by 5.

---
 src/xine-engine/video_overlay.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/xine-engine/video_overlay.h b/src/xine-engine/video_overlay.h
index 1e7a2bcca..067a4b192 100644
--- a/src/xine-engine/video_overlay.h
+++ b/src/xine-engine/video_overlay.h
@@ -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
-- 
cgit v1.2.3


From 1802e494ede1b9287fb5639c5812181d8543813a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Reinhard=20Ni=C3=9Fl?= <rnissl@gmx.de>
Date: Mon, 16 Apr 2007 00:09:15 +0200
Subject: FIX: Make sleeps in video out loops interruptable for immediate OSD
 redrawing. While splitting my original big patch set, I've lost three lines.
 This change will make xine-lib compile again.

---
 src/xine-engine/video_out.c | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'src')

diff --git a/src/xine-engine/video_out.c b/src/xine-engine/video_out.c
index d61df1eb2..6a55f9705 100644
--- a/src/xine-engine/video_out.c
+++ b/src/xine-engine/video_out.c
@@ -131,6 +131,9 @@ typedef struct {
   int                       frame_drop_limit;
   int                       frame_drop_cpt;
   int                       crop_left, crop_right, crop_top, crop_bottom;
+  pthread_mutex_t           trigger_drawing_mutex;
+  pthread_cond_t            trigger_drawing_cond;
+  int                       trigger_drawing;
 } vos_t;
 
 
-- 
cgit v1.2.3