Port the libvlc log APIs to the new internal messages API

Note that this API seems broken beyond repair to me.
It *might* crash. I cannot fix it.

diff --git a/src/control/log.c b/src/control/log.c
index b8fb181136fde997648903720c1d12e545812b79..7ef7c5168f6fd72d01145bb9d0e6c84c4b9f2366 100644 (file)
--- a/src/control/log.c
+++ b/src/control/log.c
@@ -26,18 +26,47 @@
 #include "../libvlc.h"
 #include <vlc/libvlc.h>
 
+/* This API is terminally broken.
+ * First, it does not implement any kind of notification.
+ * Second, the iterating scheme is hermetic to any kind of thread-safety
+ * owing to its constant pointer constraints.
+ *  -- Courmisch
+ *
+ * "If you break your leg, don't run to me for sympathy"
+ *   -- some character, Beneath a Steel Sky
+ */
+
+struct msg_cb_data_t
+{
+    vlc_spinlock_t lock;
+    msg_item_t *items[VLC_MSG_QSIZE];
+    unsigned    count;
+};
+
+static void handler( msg_cb_data_t *d, msg_item_t *p_item, unsigned i_drop )
+{
+    vlc_spin_lock (&d->lock);
+    if (d->count < VLC_MSG_QSIZE)
+    {
+        d->items[d->count++] = p_item;
+        /* FIXME FIXME: yield the message item */
+    }
+    vlc_spin_unlock (&d->lock);
+    (void)i_drop;
+}
+
 struct libvlc_log_t
 {
     libvlc_instance_t  *p_instance;
     msg_subscription_t *p_messages;
+    msg_cb_data_t       data;
 };
 
 struct libvlc_log_iterator_t
 {
-    msg_subscription_t *p_messages;
-    int i_start;
-    int i_pos;
-    int i_end;
+    const msg_cb_data_t *p_data;
+    unsigned i_pos;
+    unsigned i_end;
 };
 
 unsigned libvlc_get_log_verbosity( const libvlc_instance_t *p_instance, libvlc_exception_t *p_e )
@@ -69,7 +98,7 @@ libvlc_log_t *libvlc_log_open( libvlc_instance_t *p_instance, libvlc_exception_t
     if( !p_log ) RAISENULL( "Out of memory" );
 
     p_log->p_instance = p_instance;
-    p_log->p_messages = msg_Subscribe(p_instance->p_libvlc_int);
+    p_log->p_messages = msg_Subscribe(p_instance->p_libvlc_int, handler, &p_log->data);
 
     if( !p_log->p_messages )
     {
@@ -83,9 +112,10 @@ libvlc_log_t *libvlc_log_open( libvlc_instance_t *p_instance, libvlc_exception_t
 
 void libvlc_log_close( libvlc_log_t *p_log, libvlc_exception_t *p_e )
 {
-    if( p_log && p_log->p_messages )
+    if( p_log )
     {
-        msg_Unsubscribe(p_log->p_instance->p_libvlc_int, p_log->p_messages);
+        assert( p_log->p_messages );
+        msg_Unsubscribe(p_log->p_messages);
         libvlc_release( p_log->p_instance );
         free(p_log);
     }
@@ -95,26 +125,28 @@ void libvlc_log_close( libvlc_log_t *p_log, libvlc_exception_t *p_e )
 
 unsigned libvlc_log_count( const libvlc_log_t *p_log, libvlc_exception_t *p_e )
 {
-    if( p_log && p_log->p_messages )
+    if( p_log )
     {
-        int i_start = p_log->p_messages->i_start;
-        int i_stop  = *(p_log->p_messages->pi_stop);
-
-        if( i_stop >= i_start )
-            return i_stop-i_start;
-        else
-            return VLC_MSG_QSIZE-(i_start-i_stop);
+        unsigned ret;
+
+        /* We cannot lock due to pointer constraints.
+         * Even then, this would not be thread safe anyway. */
+        /*vlc_spin_lock (&p_log->data.lock);*/
+        ret = p_log->data.count;
+        /*vlc_spin_unlock (&p_log->data.lock);*/
+        return ret;
     }
     RAISEZERO("Invalid log object!");
 }
 
 void libvlc_log_clear( libvlc_log_t *p_log, libvlc_exception_t *p_e )
 {
-    if( p_log && p_log->p_messages )
+    if( p_log )
     {
-        vlc_mutex_lock(p_log->p_messages->p_lock);
-        p_log->p_messages->i_start = *(p_log->p_messages->pi_stop);
-        vlc_mutex_unlock(p_log->p_messages->p_lock);
+        vlc_spin_lock (&p_log->data.lock);
+        p_log->data.count = 0;
+        /* FIXME: release items */
+        vlc_spin_unlock (&p_log->data.lock);
     }
     else
         RAISEVOID("Invalid log object!");
@@ -122,19 +154,18 @@ void libvlc_log_clear( libvlc_log_t *p_log, libvlc_exception_t *p_e )
 
 libvlc_log_iterator_t *libvlc_log_get_iterator( const libvlc_log_t *p_log, libvlc_exception_t *p_e )
 {
-    if( p_log && p_log->p_messages )
+    if( p_log )
     {
         struct libvlc_log_iterator_t *p_iter =
             (struct libvlc_log_iterator_t *)malloc(sizeof(struct libvlc_log_iterator_t));
 
         if( !p_iter ) RAISENULL( "Out of memory" );
 
-        vlc_mutex_lock(p_log->p_messages->p_lock);
-        p_iter->p_messages = p_log->p_messages;
-        p_iter->i_start    = p_log->p_messages->i_start;
-        p_iter->i_pos      = p_log->p_messages->i_start;
-        p_iter->i_end      = *(p_log->p_messages->pi_stop);
-        vlc_mutex_unlock(p_log->p_messages->p_lock);
+        /*vlc_spin_lock (&p_log->data.lock);*/
+        p_iter->p_data  = &p_log->data;
+        p_iter->i_pos   = 0;
+        p_iter->i_end   = p_log->data.count;
+        /*vlc_spin_unlock (&p_log->data.lock);*/
 
         return p_iter;
     }
@@ -164,7 +195,7 @@ libvlc_log_message_t *libvlc_log_iterator_next( libvlc_log_iterator_t *p_iter,
                                                 libvlc_log_message_t *buffer,
                                                 libvlc_exception_t *p_e )
 {
-    int i_pos;
+    unsigned i_pos;
 
     if( !p_iter )
         RAISENULL("Invalid log iterator!");
@@ -175,18 +206,17 @@ libvlc_log_message_t *libvlc_log_iterator_next( libvlc_log_iterator_t *p_iter,
     if( i_pos != p_iter->i_end )
     {
         msg_item_t *msg;
-        vlc_mutex_lock(p_iter->p_messages->p_lock);
-        msg = p_iter->p_messages->p_msg+i_pos;
+        /*vlc_spin_lock (&p_iter->p_data->lock);*/
+        msg = p_iter->p_data->items[i_pos];
         buffer->i_severity  = msg->i_type;
         buffer->psz_type    = msg->psz_object_type;
         buffer->psz_name    = msg->psz_module;
         buffer->psz_header  = msg->psz_header;
         buffer->psz_message = msg->psz_msg;
-        p_iter->i_pos = ++i_pos % VLC_MSG_QSIZE;
-        vlc_mutex_unlock(p_iter->p_messages->p_lock);
+        /*vlc_spin_unlock (&p_iter->p_data->lock);*/
+        p_iter->i_pos++;
 
         return buffer;
     }
     RAISENULL("No more messages");
 }
-