modules/demux/mkv/Ebml_dispatcher.hpp

@@ -27,8 +27,6 @@
 #include <ebml/EbmlElement.h>
 #include <ebml/EbmlId.h>
 
-#include <vlc_threads.h>
-
 #include <algorithm>
 #include <typeinfo>
 #include <vector>

modules/demux/mkv/chapter_command.cpp

@@ -23,8 +23,18 @@
 
 #include "chapter_command.hpp"
 
+#include <vlc_arrays.h>
+
 namespace mkv {
 
+chapter_codec_cmds_c::~chapter_codec_cmds_c()
+{
+    delete p_private_data;
+    vlc_delete_all( enter_cmds );
+    vlc_delete_all( leave_cmds );
+    vlc_delete_all( during_cmds );
+}
+
 void chapter_codec_cmds_c::AddCommand( const KaxChapterProcessCommand & command )
 {
     uint32_t codec_time = uint32_t(-1);

modules/demux/mkv/chapter_command.hpp

@@ -24,7 +24,6 @@
 #ifndef VLC_MKV_CHAPTER_COMMAND_HPP_
 #define VLC_MKV_CHAPTER_COMMAND_HPP_
 
-#include <vlc_arrays.h>
 #include "mkv.hpp"
 
 struct vlc_spu_highlight_t;
@@ -61,13 +60,7 @@ public:
     ,vm( vm_ )
     {}
 
-    virtual ~chapter_codec_cmds_c()
-    {
-        delete p_private_data;
-        vlc_delete_all( enter_cmds );
-        vlc_delete_all( leave_cmds );
-        vlc_delete_all( during_cmds );
-    }
+    virtual ~chapter_codec_cmds_c();
 
     void SetPrivate( const KaxChapterProcessPrivate & private_data )
     {

modules/demux/mkv/chapters.cpp

@@ -25,6 +25,8 @@
 
 #include "chapter_command.hpp"
 
+#include <vlc_arrays.h>
+
 #include <functional>
 #include <algorithm>
 

modules/demux/mkv/events.cpp

@@ -68,23 +68,39 @@ void event_thread_t::ResetPci()
     if( !is_running )
         return;
 
-    vlc_mutex_lock( &lock );
-    b_abort = true;
-    vlc_cond_signal( &wait );
-    vlc_mutex_unlock( &lock );
+    {
+        vlc_mutex_locker lock_guard(&lock);
+        b_abort = true;
+        vlc_cond_signal( &wait );
+    }
 
     vlc_join( thread, NULL );
     is_running = false;
 }
 
-int event_thread_t::SendEventNav( int nav_query )
+int event_thread_t::SendEventNav( demux_query_e nav_query )
 {
+    NavivationKey key;
+    switch( nav_query )
+    {
+    case DEMUX_NAV_LEFT:     key = NavivationKey::LEFT;  break;
+    case DEMUX_NAV_RIGHT:    key = NavivationKey::RIGHT; break;
+    case DEMUX_NAV_UP:       key = NavivationKey::UP;    break;
+    case DEMUX_NAV_DOWN:     key = NavivationKey::DOWN;  break;
+    case DEMUX_NAV_ACTIVATE: key = NavivationKey::OK;    break;
+    case DEMUX_NAV_MENU:     key = NavivationKey::MENU;  break;
+    case DEMUX_NAV_POPUP:    key = NavivationKey::POPUP; break;
+    default:
+        assert(false); // invalid navigation query received
+        return VLC_ENOTSUP;
+    }
+
     if( !is_running )
         return VLC_EGENERIC;
 
     vlc_mutex_locker lock_guard( &lock );
 
-    pending_events.push_back( EventInfo( nav_query ) );
+    pending_events.push_back( EventInfo( key ) );
 
     vlc_cond_signal( &wait );
 
@@ -100,7 +116,7 @@ void event_thread_t::EventMouse( vlc_mouse_t const* new_state, void* userdata )
         return vlc_mouse_Init( &info->mouse_state );
 
     info->owner.pending_events.push_back(
-        EventInfo( info, info->mouse_state, *new_state ) );
+        EventInfo( info->mouse_state, *new_state ) );
 
     vlc_cond_signal( &info->owner.wait );
     info->mouse_state = *new_state;
@@ -152,20 +168,7 @@ void event_thread_t::HandleKeyEvent( EventInfo const& ev )
 {
     msg_Dbg( p_demux, "Handle Key Event");
 
-    NavivationKey key;
-    switch( ev.nav.query )
-    {
-    case DEMUX_NAV_LEFT:     key = NavivationKey::LEFT;
-    case DEMUX_NAV_RIGHT:    key = NavivationKey::RIGHT;
-    case DEMUX_NAV_UP:       key = NavivationKey::UP;
-    case DEMUX_NAV_DOWN:     key = NavivationKey::DOWN;
-    case DEMUX_NAV_ACTIVATE: key = NavivationKey::OK;
-    case DEMUX_NAV_MENU:     key = NavivationKey::MENU;
-    case DEMUX_NAV_POPUP:    key = NavivationKey::POPUP;
-    default:                 return;
-    }
-
-    HandleKeyEvent( key );
+    HandleKeyEvent( ev.nav.key );
 }
 
 void event_thread_t::HandleKeyEvent( NavivationKey key )
@@ -177,12 +180,12 @@ void event_thread_t::HandleKeyEvent( NavivationKey key )
         return;
 
     vlc_mutex_unlock( &lock );
-    vlc_mutex_lock( &p_sys->lock_demuxer );
-
-    // process the button action
-    interpretor->HandleKeyEvent( key );
+    {
+        vlc_mutex_locker demux_lock ( &p_sys->lock_demuxer );
 
-    vlc_mutex_unlock( &p_sys->lock_demuxer );
+        // process the button action
+        interpretor->HandleKeyEvent( key );
+    }
     vlc_mutex_lock( &lock );
 }
 
@@ -213,9 +216,11 @@ void event_thread_t::HandleMousePressed( unsigned x, unsigned y )
     msg_Dbg( p_demux, "Handle Mouse Event: Mouse clicked x(%d)*y(%d)", x, y);
 
     vlc_mutex_unlock( &lock );
-    vlc_mutex_lock( &p_sys->lock_demuxer );
-    interpretor->HandleMousePressed( x, y );
-    vlc_mutex_unlock( &p_sys->lock_demuxer );
+    {
+        vlc_mutex_locker demux_lock ( &p_sys->lock_demuxer );
+
+        interpretor->HandleMousePressed( x, y );
+    }
     vlc_mutex_lock( &lock );
 }
 
@@ -224,24 +229,28 @@ void event_thread_t::SetHighlight( vlc_spu_highlight_t & spu_hl )
     /* TODO: only control relevant SPU_ES given who fired the event */
     for( auto it : es_list )
     {
-        if( it.category != SPU_ES )
+        if( it.track.fmt.i_cat != SPU_ES )
             continue;
 
-        es_out_Control( p_demux->out, ES_OUT_SPU_SET_HIGHLIGHT, it.es, &spu_hl );
+        es_out_Control( p_demux->out, ES_OUT_SPU_SET_HIGHLIGHT, it.track.p_es, &spu_hl );
     }
 }
 
-bool event_thread_t::AddES( es_out_id_t* es, int category )
+bool event_thread_t::AddTrack( mkv_track_t & track )
 {
+    es_out_id_t* es = track.p_es;
+    int category = track.fmt.i_cat;
+
     vlc_mutex_locker lock_guard( &lock );
 
-    es_list.push_front( ESInfo( es, category, *this ) );
+    es_list.push_front( ESInfo( track, *this ) );
     es_list_t::iterator info = es_list.begin();
 
     if( category == VIDEO_ES )
     {
         if( es_out_Control( p_demux->out, ES_OUT_VOUT_SET_MOUSE_EVENT,
-                            es, EventMouse, static_cast<void*>( &*info ) ) )
+                            es, static_cast<vlc_mouse_event>(EventMouse),
+                            static_cast<void*>( &*info ) ) )
         {
             msg_Warn( p_demux, "Unable to subscribe to mouse events" );
             es_list.erase( info );
@@ -251,10 +260,10 @@ bool event_thread_t::AddES( es_out_id_t* es, int category )
     return true;
 }
 
-void event_thread_t::DelES( es_out_id_t* es )
+void event_thread_t::DelTrack( mkv_track_t &track )
 {
     vlc_mutex_locker lock_guard( &lock );
-    es_list_t::iterator info = std::find( es_list.begin(), es_list.end(), es );
+    es_list_t::iterator info = std::find( es_list.begin(), es_list.end(), track );
     if( info != es_list.end() )
         es_list.erase( info );
 }

modules/demux/mkv/events.hpp

@@ -46,28 +46,26 @@ public:
 
     void SetPci(const pci_t *data);
     void ResetPci();
-    int SendEventNav( int );
+    int SendEventNav( demux_query_e );
     void SetHighlight( vlc_spu_highlight_t & spu_hl );
 
-    bool AddES( es_out_id_t* es, int category );
-    void DelES( es_out_id_t* es );
+    bool AddTrack( mkv_track_t & );
+    void DelTrack( mkv_track_t & );
 
 private:
     struct ESInfo {
-        ESInfo( es_out_id_t* es, int category, event_thread_t& owner )
-            : es( es )
-            , category( category )
+        ESInfo( mkv_track_t & track_, event_thread_t& owner )
+            : track( track_ )
             , owner( owner )
         {
             vlc_mouse_Init( &mouse_state );
         }
 
-        bool operator==( es_out_id_t* es ) const {
-            return this->es == es;
+        bool operator==( const mkv_track_t & t ) const {
+            return track.p_es == t.p_es;
         }
 
-        es_out_id_t* es;
-        int category;
+        mkv_track_t & track;
         event_thread_t& owner;
         vlc_mouse_t mouse_state;
     };
@@ -78,29 +76,26 @@ private:
             ActionEvent,
         } type;
 
-        EventInfo( ESInfo* info, vlc_mouse_t state_old, vlc_mouse_t state_new )
+        EventInfo( const vlc_mouse_t & state_old, const vlc_mouse_t & state_new )
             : type( ESMouseEvent )
+            , mouse{ state_old, state_new }
         {
-            mouse.es_info = info;
-            mouse.state_old = state_old;
-            mouse.state_new = state_new;
         }
 
-        EventInfo( int query )
+        EventInfo( NavivationKey key )
             : type( ActionEvent )
+            , nav{ key }
         {
-            nav.query = query;
         }
 
         union {
             struct {
-                ESInfo* es_info;
-                vlc_mouse_t state_old;
-                vlc_mouse_t state_new;
+                const vlc_mouse_t state_old;
+                const vlc_mouse_t state_new;
             } mouse;
 
             struct {
-                int query;
+                const NavivationKey key;
             } nav;
         };
     };

modules/demux/mkv/matroska_segment.cpp

@@ -27,6 +27,8 @@
 #include "util.hpp"
 #include "Ebml_dispatcher.hpp"
 
+#include <vlc_arrays.h>
+
 #include <new>
 #include <iterator>
 #include <limits>
@@ -1132,7 +1134,7 @@ bool matroska_segment_c::ESCreate()
             track.p_es = es_out_Add( sys.demuxer.out, &track.fmt );
 
             if( track.p_es &&
-                !sys.ev.AddES( track.p_es, track.fmt.i_cat ) )
+                !sys.ev.AddTrack( track ) )
             {
                 msg_Warn( &sys.demuxer, "Could not register events, interactive menus will not work");
             }
@@ -1171,7 +1173,7 @@ void matroska_segment_c::ESDestroy( )
         if( track.p_es != NULL )
         {
             es_out_Del( sys.demuxer.out, track.p_es );
-            sys.ev.DelES( track.p_es );
+            sys.ev.DelTrack( track );
             track.p_es = NULL;
         }
     }

modules/demux/mkv/mkv.cpp

@@ -483,7 +483,7 @@ static int Control( demux_t *p_demux, int i_query, va_list args )
         case DEMUX_NAV_RIGHT:
         case DEMUX_NAV_POPUP:
         case DEMUX_NAV_MENU:
-            return p_sys->ev.SendEventNav( i_query );
+            return p_sys->ev.SendEventNav( static_cast<demux_query_e>(i_query) );
 
         case DEMUX_CAN_PAUSE:
         case DEMUX_SET_PAUSE_STATE: